small refactoring

Author: nodkz

src/AwsApiParser.js

@@ -3,6 +3,7 @@
 import { TypeComposer } from 'graphql-compose';
 import type { GraphQLObjectType, GraphQLFieldConfig } from 'graphql-compose/lib/graphql';
 import AwsService, { type ServiceConfig } from './AwsService';
+import AwsConfigITC from './types/AwsConfigITC';
 
 export type AwsSDK = any;
 
@@ -15,22 +16,41 @@ export default class AwsApiParser {
   name: string;
   awsSDK: AwsSDK;
   tc: TypeComposer;
+  _serviceMap: { [serviceIdentifier: string]: string };
 
   constructor(opts: AwsOpts) {
     this.name = opts.name || 'Aws';
     this.awsSDK = opts.awsSDK;
+
+    this._serviceMap = {};
+    this.getServicesNames();
   }
 
   getServicesNames(): string[] {
-    const serviceNames = Object.keys(this.awsSDK.apiLoader.services);
+    const serviceNames = Object.keys(this.awsSDK).reduce((res, name) => {
+      if (this.awsSDK[name].serviceIdentifier) {
+        this._serviceMap[this.awsSDK[name].serviceIdentifier] = name;
+        res.push(name);
+      }
+      return res;
+    }, []);
     serviceNames.sort();
     return serviceNames;
   }
 
+  getServiceIdentifier(name: string): string {
+    if (this._serviceMap[name]) return name;
+
+    if (!this.awsSDK[name]) {
+      throw new Error(`Service with name '${name}' does not exist. Run AwsApiParser.`);
+    }
+    return this.awsSDK[name].serviceIdentifier;
+  }
+
   getServiceConfig(name: string): ServiceConfig {
-    const cfg = this.awsSDK.apiLoader.services[name];
+    const cfg = this.awsSDK.apiLoader.services[this.getServiceIdentifier(name)];
     if (!cfg) {
-      throw new Error(`Service with name ${name} does not exist.`);
+      throw new Error(`Service with name '${name}' does not exist.`);
     }
     const versions = Object.keys(cfg);
     if (versions.length === 1) {
@@ -42,18 +62,20 @@ export default class AwsApiParser {
   }
 
   getService(name: string): AwsService {
+    const config = this.getServiceConfig(name);
+    // console.log(config);
     return new AwsService({
-      serviceId: name,
+      serviceId: this._serviceMap[name] || name,
       prefix: this.name,
-      config: this.getServiceConfig(name),
+      config,
       awsSDK: this.awsSDK,
     });
   }
 
   getTypeComposer(): TypeComposer {
     if (!this.tc) {
       const fields = this.getServicesNames().reduce((res, name) => {
-        res[name] = this.getService(name).getTypeComposer();
+        res[this.getServiceIdentifier(name)] = this.getService(name).getFieldConfig();
         return res;
       }, {});
 
@@ -73,6 +95,15 @@ export default class AwsApiParser {
   getFieldConfig(): GraphQLFieldConfig<any, any> {
     return {
       type: this.getType(),
+      args: {
+        config: {
+          type: AwsConfigITC.getType(),
+          description: 'Will override default configs for aws-sdk.',
+        },
+      },
+      resolve: (source, args) => ({
+        awsConfig: { ...(source && source.awsConfig), ...(args && args.config) },
+      }),
       description: this.getTypeComposer().getDescription(),
     };
   }

src/AwsService.js

@@ -1,11 +1,12 @@
 /* @flow */
 
 import { TypeComposer, upperFirst } from 'graphql-compose';
-import type { GraphQLObjectType } from 'graphql-compose/lib/graphql';
+import type { GraphQLObjectType, GraphQLFieldConfig } from 'graphql-compose/lib/graphql';
 import AwsServiceMetadata, { type ServiceMetadataConfig } from './AwsServiceMetadata';
 import AwsServiceOperation, { type ServiceOperationConfig } from './AwsServiceOperation';
 import AwsShapes, { type ShapesMap } from './AwsShapes';
 import type { AwsSDK } from './AwsApiParser';
+import AwsConfigITC from './types/AwsConfigITC';
 
 export type ServiceConfig = {
   version: string,
@@ -48,6 +49,10 @@ export default class AwsService {
     return `${this.prefix}${upperFirst(this.serviceId)}`;
   }
 
+  static lowerFirst(name: string) {
+    return name.charAt(0).toLowerCase() + name.slice(1);
+  }
+
   getOperationNames(): string[] {
     return Object.keys(this.config.operations);
   }
@@ -59,7 +64,7 @@ export default class AwsService {
     }
     return new AwsServiceOperation({
       serviceId: this.serviceId,
-      name,
+      name: this.constructor.lowerFirst(name),
       prefix: this.prefix,
       config: operConfig,
       shapes: this.shapes,
@@ -70,7 +75,7 @@ export default class AwsService {
   getTypeComposer(): TypeComposer {
     if (!this.tc) {
       const fields = this.getOperationNames().reduce((res, name) => {
-        res[name] = this.getOperation(name).getFieldConfig();
+        res[this.constructor.lowerFirst(name)] = this.getOperation(name).getFieldConfig();
         return res;
       }, {});
 
@@ -86,4 +91,19 @@ export default class AwsService {
   getType(): GraphQLObjectType {
     return this.getTypeComposer().getType();
   }
+
+  getFieldConfig(): GraphQLFieldConfig<any, any> {
+    return {
+      type: this.getType(),
+      args: {
+        config: {
+          type: AwsConfigITC.getType(),
+          description: 'Will override default configs for aws-sdk.',
+        },
+      },
+      resolve: (source, args) => ({
+        awsConfig: { ...(source && source.awsConfig), ...(args && args.config) },
+      }),
+    };
+  }
 }

src/AwsServiceOperation.js

@@ -10,6 +10,7 @@ import type {
 import AwsParam, { type ParamStructure } from './AwsParam';
 import type AwsShapes from './AwsShapes';
 import type { AwsSDK } from './AwsApiParser';
+import AwsConfigITC from './types/AwsConfigITC';
 
 export type ServiceOperationConfig = {
   http?: {
@@ -97,6 +98,10 @@ export default class AwsServiceOperation {
           },
         };
       }
+
+      this.args.config = {
+        type: AwsConfigITC.getType(),
+      };
     }
 
     return this.args;
@@ -105,7 +110,12 @@ export default class AwsServiceOperation {
   getResolve(): GraphQLFieldResolver<any, any> {
     return ((source: any, args: { [argument: string]: any }) => {
       return new Promise((resolve, reject) => {
-        this.awsSDK[this.serviceId][this.name](args, (err, data) => {
+        const awsConfig = {
+          ...(source && source.awsConfig),
+          ...(args && args.config),
+        };
+        const service = new this.awsSDK[this.serviceId](awsConfig);
+        service[this.name](args.input, (err, data) => {
           if (err) {
             reject(err);
           }
@@ -120,7 +130,6 @@ export default class AwsServiceOperation {
       type: this.getType(),
       args: this.getArgs(),
       resolve: this.getResolve(),
-      description: `${this.serviceId}.${this.name}`,
     };
   }
 }

src/__mocks__/elasticClient.js

@@ -3,6 +3,7 @@
 import awsSDK from 'aws-sdk';
 import AwsApiParser from '../AwsApiParser';
 import AwsService from '../AwsService';
+import AwsConfigITC from '../types/AwsConfigITC';
 
 describe('AwsApiParser', () => {
   const aws = new AwsApiParser({
@@ -11,14 +12,20 @@ describe('AwsApiParser', () => {
 
   it('getServicesNames()', () => {
     const names = aws.getServicesNames();
-    expect(names).toContain('s3');
-    expect(names).toContain('ec2');
-    expect(names).toContain('route53');
-    expect(names).toContain('sqs');
+    expect(names).toContain('S3');
+    expect(names).toContain('EC2');
+    expect(names).toContain('Route53');
+    expect(names).toContain('SQS');
+  });
+
+  it('getServiceIdentifier()', () => {
+    expect(aws.getServiceIdentifier('S3')).toBe('s3');
+    // also should work if provided serviceIdentifier
+    expect(aws.getServiceIdentifier('s3')).toBe('s3');
   });
 
   it('getServiceConfig()', () => {
-    const cfg = aws.getServiceConfig('s3');
+    const cfg = aws.getServiceConfig('S3');
     expect(Object.keys(cfg)).toEqual([
       'version',
       'metadata',
@@ -27,24 +34,37 @@ describe('AwsApiParser', () => {
       'paginators',
       'waiters',
     ]);
+
+    // get config by serviceIdentifier
+    const cfg2 = aws.getServiceConfig('s3');
+    expect(Object.keys(cfg2)).toEqual([
+      'version',
+      'metadata',
+      'operations',
+      'shapes',
+      'paginators',
+      'waiters',
+    ]);
   });
 
   it('getService()', () => {
-    const service = aws.getService('s3');
+    const service = aws.getService('S3');
     expect(service).toBeInstanceOf(AwsService);
+
+    // get service by serviceIdentifier
+    const service2 = aws.getService('s3');
+    expect(service2).toBeInstanceOf(AwsService);
   });
 
   it('getType()', () => {
     const type = aws.getType();
     expect(type.name).toBe('Aws');
   });
-});
 
-// export default class Aws {
-//   constructor(opts: AwsOpts) {
-//   getServicesNames(): string[] {
-//   getServiceConfig(name: string): ServiceConfig {
-//   getService(name: string): AwsService {
-//   getTypeComposer(): TypeComposer {
-//   getType(): GraphQLObjectType {
-// }
+  it('getFieldConfig()', () => {
+    const fc: any = aws.getFieldConfig();
+    expect(fc.type).toBe(aws.getType());
+    expect(fc.args.config.type).toBe(AwsConfigITC.getType());
+    expect(fc.resolve()).toEqual({ awsConfig: {} });
+  });
+});

src/__tests__/AwsApiParser-test.js

@@ -3,6 +3,7 @@
 import AwsService from '../AwsService';
 import AwsServiceOperation from '../AwsServiceOperation';
 import s3Cfg from '../__mocks__/s3-2006-03-01.json';
+import AwsConfigITC from '../types/AwsConfigITC';
 
 describe('AwsService', () => {
   const s3 = new AwsService({
@@ -30,11 +31,19 @@ describe('AwsService', () => {
   it('getTypeComposer()', () => {
     const tc = s3.getTypeComposer();
     expect(tc.getTypeName()).toBe('AwsS3');
-    expect(tc.getFieldNames()).toContain('CreateBucket');
+    expect(tc.getFieldNames()).toContain('createBucket');
+    expect(tc.getFieldNames()).toContain('deleteObject');
   });
 
   it('getType()', () => {
     const type = s3.getType();
     expect(type.name).toBe('AwsS3');
   });
+
+  it('getFieldConfig()', () => {
+    const fc: any = s3.getFieldConfig();
+    expect(fc.type).toBe(s3.getType());
+    expect(fc.args.config.type).toBe(AwsConfigITC.getType());
+    expect(fc.resolve()).toEqual({ awsConfig: {} });
+  });
 });

src/__tests__/AwsService-test.js

@@ -1,4 +1,5 @@
 /* @flow */
+/* eslint-disable class-methods-use-this */
 
 import {
   GraphQLInputObjectType,
@@ -7,6 +8,7 @@ import {
   isOutputType,
 } from 'graphql-compose/lib/graphql';
 import AwsServiceOperation from '../AwsServiceOperation';
+import AwsConfigITC from '../types/AwsConfigITC';
 
 const operations = {
   CreateBucket: {
@@ -73,9 +75,9 @@ const operations = {
 };
 
 describe('AwsJsonParserOperation', () => {
-  const AWSMock = {
-    S3: {
-      CreateBucket: jest.fn(),
+  const AWSMock: any = {
+    S3: class S3 {
+      CreateBucket(args, cb) {} // eslint-disable-line
     },
   };
 
@@ -114,32 +116,35 @@ describe('AwsJsonParserOperation', () => {
     });
 
     it('resolves', async () => {
-      AWSMock.S3.CreateBucket = jest.fn((args, cb) => {
-        cb(undefined, { payload: args });
-      });
-      const res = await resolve({}, { arg: 123 }, ({}: any), ({}: any));
+      AWSMock.S3 = class S3WithPayload {
+        CreateBucket(args, cb) {
+          cb(undefined, { payload: args });
+        }
+      };
+      const res = await resolve({}, { input: { arg: 123 } }, ({}: any), ({}: any));
       expect(res).toEqual({ payload: { arg: 123 } });
     });
 
     it('rejects', async () => {
-      AWSMock.S3.CreateBucket = jest.fn((args, cb) => {
-        cb('err');
-      });
+      AWSMock.S3 = class S3WithError {
+        CreateBucket(args, cb) {
+          cb('err');
+        }
+      };
 
       expect.assertions(1);
       try {
-        await resolve({}, { arg: 123 }, ({}: any), ({}: any));
+        await resolve({}, {}, ({}: any), ({}: any));
       } catch (e) {
         expect(e).toBe('err');
       }
     });
   });
 
   it('getFieldConfig()', () => {
-    const fc = oper.getFieldConfig();
+    const fc: any = oper.getFieldConfig();
     expect(fc.type).toBeInstanceOf(GraphQLObjectType);
-    expect(fc.args).toBeDefined();
+    expect(fc.args.config.type).toBe(AwsConfigITC.getType());
     expect((fc.resolve: any).call).toBeDefined();
-    expect(fc.description).toBe('S3.CreateBucket');
   });
 });