chore: fix flowtype definitions and cove rest tests files by flow

Author: nodkz

flow-typed/npm/mongoose_v4.x.x.js

@@ -553,7 +553,7 @@ declare module "mongoose" {
     models: { [name: string]: typeof Mongoose$Document },
     createConnection(uri?: string, options?: Object): Mongoose$Connection,
     set: (key: string, value: string | Function | boolean) => void,
-    connect: (uri: string, options?: Object) => void,
+    connect: (uri?: string, options?: Object) => void,
     connection: Mongoose$Connection,
     connections: Mongoose$Connection[],
     Query: typeof Mongoose$Query,

src/__tests__/composeWithMongooseDiscriminators-test.js

@@ -16,9 +16,7 @@ import { DiscriminatorTypeComposer } from '../discriminators';
 beforeAll(() => MovieModel.base.connect());
 afterAll(() => MovieModel.base.disconnect());
 
-export const allowedDKeys = ['type', 'kind', 'error'];
-
-const { CharacterModel, PersonModel, DroidModel } = getCharacterModels(allowedDKeys[0]);
+const { CharacterModel, PersonModel, DroidModel } = getCharacterModels('type');
 
 describe('composeWithMongooseDiscriminators ->', () => {
   beforeEach(() => {
@@ -50,14 +48,14 @@ describe('composeWithMongooseDiscriminators ->', () => {
         customizationOptions: {
           inputType: {
             fields: {
-              required: [allowedDKeys[1]],
+              required: ['kind'],
             },
           },
         },
       });
       const filterArgInFindOne: any = typeComposer.getResolver('findOne').getArg('filter');
       const inputComposer = new InputTypeComposer(filterArgInFindOne.type);
-      expect(inputComposer.isRequired(allowedDKeys[1])).toBe(true);
+      expect(inputComposer.isRequired('kind')).toBe(true);
     });
 
     it('should proceed customizationOptions.inputType.fields.required', () => {
@@ -90,7 +88,7 @@ describe('composeWithMongooseDiscriminators ->', () => {
       expect(baseDTC.getFieldNames()).toEqual(Object.keys(baseDTC.getDInterface().getFields()));
 
       beforeAll(() =>
-        baseDTC.addDFields({
+        baseDTC.addFields({
           field1: 'String',
           field2: 'String',
         }));
@@ -177,7 +175,7 @@ describe('composeWithMongooseDiscriminators ->', () => {
       const characterDTC = composeWithMongooseDiscriminators(CharacterModel);
       const personTC = characterDTC.discriminator(PersonModel);
       const droidTC = characterDTC.discriminator(DroidModel);
-      const fieldName = allowedDKeys[1];
+      const fieldName = 'kind';
       const fieldExtension = {
         type: 'String',
         description: 'Hello I am changed',
@@ -190,7 +188,9 @@ describe('composeWithMongooseDiscriminators ->', () => {
       it('should extend field on baseTC', () => {
         expect(characterDTC.getFieldType(fieldName).toString()).toEqual(graphql.GraphQLString.name);
 
-        expect(characterDTC.getField(fieldName).description).toEqual(fieldExtension.description);
+        expect((characterDTC.getField(fieldName): any).description).toEqual(
+          fieldExtension.description
+        );
       });
 
       it('should extend field type on DInterface', () => {
@@ -206,11 +206,11 @@ describe('composeWithMongooseDiscriminators ->', () => {
       it('should extend field on childTC', () => {
         expect(personTC.getFieldType(fieldName).toString()).toEqual(graphql.GraphQLString.name);
 
-        expect(personTC.getField(fieldName).description).toEqual(fieldExtension.description);
+        expect((personTC.getField(fieldName): any).description).toEqual(fieldExtension.description);
 
         expect(droidTC.getFieldType(fieldName).toString()).toEqual(graphql.GraphQLString.name);
 
-        expect(droidTC.getField(fieldName).description).toEqual(fieldExtension.description);
+        expect((droidTC.getField(fieldName): any).description).toEqual(fieldExtension.description);
       });
     });
 

src/__tests__/integration-discriminators-test.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import { graphql, schemaComposer } from 'graphql-compose/lib/index';
 import { mongoose } from '../__mocks__/mongooseCommon';
 import { getCharacterModels } from '../__mocks__/characterModels';

src/composeWithMongooseDiscriminators.js

@@ -1,10 +1,10 @@
 /* @flow */
 
-import { Model } from 'mongoose';
+import type { Model } from 'mongoose';
 import { type Options, DiscriminatorTypeComposer } from './discriminators';
 
 export function composeWithMongooseDiscriminators(
-  baseModel: Model,
+  baseModel: Class<Model>,
   opts?: Options
 ): DiscriminatorTypeComposer<any> {
   return DiscriminatorTypeComposer.createFromModel(baseModel, opts);

src/discriminators/DiscriminatorTypeComposer.js

@@ -7,15 +7,12 @@ import {
   SchemaComposer,
   TypeComposerClass,
   type InterfaceTypeComposerClass,
+  type ComposeFieldConfig,
+  type RelationOpts,
+  type GetRecordIdFn,
 } from 'graphql-compose';
-import type { GraphQLFieldConfigMap } from 'graphql-compose/lib/graphql';
-import type {
-  ComposePartialFieldConfigAsObject,
-  RelationOpts,
-  ComposeFieldConfig,
-  GetRecordIdFn,
-} from 'graphql-compose/lib/TypeComposer';
-import { Model } from 'mongoose';
+import type { ComposePartialFieldConfigAsObject } from 'graphql-compose/lib/TypeComposer';
+import type { Model } from 'mongoose';
 import { composeWithMongoose, type TypeConverterOpts } from '../composeWithMongoose';
 import { composeChildTC } from './composeChildTC';
 import { mergeCustomizationOptions } from './merge-customization-options';
@@ -95,7 +92,7 @@ export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TCont
   }
   */
 
-  static createFromModel(baseModel: Model, opts?: any): DiscriminatorTypeComposer<TContext> {
+  static createFromModel(baseModel: Class<Model>, opts?: any): DiscriminatorTypeComposer<TContext> {
     if (!baseModel || !(baseModel: any).discriminators) {
       throw Error('Discriminator Key not Set, Use composeWithMongoose for Normal Collections');
     }
@@ -168,7 +165,7 @@ export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TCont
     return this.DKeyETC;
   }
 
-  getDInterface(): GraphQLInterfaceType {
+  getDInterface(): InterfaceTypeComposerClass<TContext> {
     return this.DInterface;
   }
 
@@ -323,7 +320,7 @@ export class DiscriminatorTypeComposer<TContext> extends TypeComposerClass<TCont
   }
 
   /* eslint no-use-before-define: 0 */
-  discriminator(childModel: Model, opts?: TypeConverterOpts): TypeComposerClass<TContext> {
+  discriminator(childModel: Class<Model>, opts?: TypeConverterOpts): TypeComposerClass<TContext> {
     const customizationOpts = mergeCustomizationOptions(
       (this.opts: any).customizationOptions,
       opts

src/discriminators/merge-customization-options/utils/mergeTypeConverterResolversOpts.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 import type { TypeConverterResolversOpts } from '../../../composeWithMongoose';
 import { MergeAbleHelperArgsOpts } from '../../../resolvers/helpers';
 import { mergeStringAndStringArraysFields } from '../index';
@@ -115,13 +117,17 @@ export function mergeMapTypeFields(baseField: any, childField: any, argOptsTypes
 }
 
 export function mergeTypeConverterResolverOpts(
-  baseTypeConverterResolverOpts: TypeConverterResolversOpts,
-  childTypeConverterResolverOpts: TypeConverterResolversOpts
-) {
+  baseTypeConverterResolverOpts?: TypeConverterResolversOpts | false,
+  childTypeConverterResolverOpts?: TypeConverterResolversOpts | false
+): TypeConverterResolversOpts | false | void {
   if (!baseTypeConverterResolverOpts) {
     return childTypeConverterResolverOpts;
   }
 
+  if (!childTypeConverterResolverOpts) {
+    return baseTypeConverterResolverOpts;
+  }
+
   const mergedTypeConverterResolverOpts =
     JSON.parse(JSON.stringify(childTypeConverterResolverOpts)) || {};