fix(typing): expose type defs ComposeWithMongooseOpts and others

Author: nodkz

src/composeWithMongoose.d.ts

@@ -13,7 +13,7 @@ import {
 } from './resolvers/helpers';
 import { PaginationResolverOpts } from './resolvers/pagination';
 
-export type TypeConverterOpts<TContext = any> = {
+export type ComposeWithMongooseOpts<TContext = any> = {
   schemaComposer?: SchemaComposer<TContext>;
   name?: string;
   description?: string;
@@ -116,7 +116,7 @@ export function composeWithMongoose<
   TContext = any
 >(
   model: Model<TModel>,
-  opts?: TypeConverterOpts<TContext>,
+  opts?: ComposeWithMongooseOpts<TContext>,
 ): ObjectTypeComposer<TModel, TContext>;
 
 export function prepareFields(

src/composeWithMongoose.js

@@ -16,7 +16,7 @@ import MongoID from './types/mongoid';
 import type { PaginationResolverOpts } from './resolvers/pagination';
 import type { ConnectionSortMapOpts } from './resolvers/connection';
 
-export type TypeConverterOpts<TContext> = {|
+export type ComposeWithMongooseOpts<TContext> = {|
   schemaComposer?: SchemaComposer<TContext>,
   name?: string,
   description?: string,
@@ -117,7 +117,7 @@ export type TypeConverterResolversOpts = {
 
 export function composeWithMongoose<TSource, TContext>(
   model: Class<TSource>, // === MongooseModel,
-  opts: TypeConverterOpts<TContext> = ({}: any)
+  opts: ComposeWithMongooseOpts<TContext> = ({}: any)
 ): ObjectTypeComposer<TSource, TContext> {
   const m: MongooseModel = (model: any);
   const name: string = (opts && opts.name) || m.modelName;

src/composeWithMongooseDiscriminators.d.ts

@@ -1,13 +1,15 @@
 import { Document, Model } from 'mongoose';
 import {
-  DiscriminatorOptions,
+  ComposeWithMongooseDiscriminatorsOpts,
   DiscriminatorTypeComposer,
 } from './discriminators';
 
+export * from './discriminators';
+
 export function composeWithMongooseDiscriminators<
   TBaseModel extends Document = any,
   TContext = any
 >(
   baseModel: Model<TBaseModel>,
-  opts?: DiscriminatorOptions<TContext>,
+  opts?: ComposeWithMongooseDiscriminatorsOpts<TContext>,
 ): DiscriminatorTypeComposer<TBaseModel, TContext>;

src/composeWithMongooseDiscriminators.js

@@ -2,11 +2,16 @@
 
 import { schemaComposer as globalSchemaComposer } from 'graphql-compose';
 import type { MongooseModel } from 'mongoose';
-import { type DiscriminatorOptions, DiscriminatorTypeComposer } from './discriminators';
+import {
+  type ComposeWithMongooseDiscriminatorsOpts,
+  DiscriminatorTypeComposer,
+} from './discriminators';
+
+export * from './discriminators';
 
 export function composeWithMongooseDiscriminators<TSource, TContext>(
   baseModel: Class<TSource>, // === MongooseModel,
-  opts?: DiscriminatorOptions<TContext>
+  opts?: ComposeWithMongooseDiscriminatorsOpts<TContext>
 ): DiscriminatorTypeComposer<TSource, TContext> {
   const m: MongooseModel = (baseModel: any);
   const sc = (opts ? opts.schemaComposer : null) || globalSchemaComposer;

src/discriminators/DiscriminatorTypeComposer.d.ts

@@ -9,11 +9,11 @@ import {
   ObjectTypeComposer,
 } from 'graphql-compose';
 import { Document, Model } from 'mongoose';
-import { TypeConverterOpts } from '../composeWithMongoose';
+import { ComposeWithMongooseOpts } from '../composeWithMongoose';
 
-export type DiscriminatorOptions<TContext = any> = TypeConverterOpts<
-  TContext
-> & {
+export type ComposeWithMongooseDiscriminatorsOpts<
+  TContext = any
+> = ComposeWithMongooseOpts<TContext> & {
   reorderFields?: boolean | string[]; // true order: _id, DKey, DInterfaceFields, DiscriminatorFields
 };
 
@@ -27,15 +27,15 @@ export class DiscriminatorTypeComposer<
 
   private DKeyETC: EnumTypeComposer;
 
-  private opts: DiscriminatorOptions<TContext>;
+  private opts: ComposeWithMongooseDiscriminatorsOpts<TContext>;
 
   private DInterface: InterfaceTypeComposer<any>;
 
   private childTCs: Array<ObjectTypeComposer<any>>;
 
   public static createFromModel<TBModel extends Document, TCtx>(
     baseModel: Model<TBModel>,
-    opts?: DiscriminatorOptions<TCtx>,
+    opts?: ComposeWithMongooseDiscriminatorsOpts<TCtx>,
   ): DiscriminatorTypeComposer<TBModel, TCtx>;
 
   // ------------------------------------------------
@@ -51,7 +51,7 @@ export class DiscriminatorTypeComposer<
 
   public discriminator<TChildModel extends TBaseModel>(
     childModel: Model<TChildModel>,
-    opts?: TypeConverterOpts<TContext>,
+    opts?: ComposeWithMongooseOpts<TContext>,
   ): ObjectTypeComposer<TChildModel, TContext>;
 
   // ------------------------------------------------
@@ -69,9 +69,7 @@ export class DiscriminatorTypeComposer<
 
   public setFields(fields: ComposeFieldConfigMap<TBaseModel, TContext>): this;
 
-  public setFields(
-    fields: ComposeFieldConfigMap<TBaseModel, TContext>,
-  ): this;
+  public setFields(fields: ComposeFieldConfigMap<TBaseModel, TContext>): this;
 
   // discriminators must have all interface fields
   public addFields(

src/discriminators/DiscriminatorTypeComposer.js

@@ -13,15 +13,15 @@ import {
 } from 'graphql-compose';
 import type { ComposeFieldConfigAsObject } from 'graphql-compose/lib/ObjectTypeComposer';
 import type { Model } from 'mongoose';
-import { composeWithMongoose, type TypeConverterOpts } from '../composeWithMongoose';
+import { composeWithMongoose, type ComposeWithMongooseOpts } from '../composeWithMongoose';
 import { composeChildTC } from './composeChildTC';
 import { mergeCustomizationOptions } from './utils/mergeCustomizationOptions';
 import { prepareBaseResolvers } from './prepareBaseResolvers';
 import { reorderFields } from './utils/reorderFields';
 
-export type DiscriminatorOptions<TContext> = {|
+export type ComposeWithMongooseDiscriminatorsOpts<TContext> = {|
   reorderFields?: boolean | string[], // true order: _id, DKey, DInterfaceFields, DiscriminatorFields
-  ...TypeConverterOpts<TContext>,
+  ...ComposeWithMongooseOpts<TContext>,
 |};
 
 type Discriminators = {
@@ -75,7 +75,7 @@ export class DiscriminatorTypeComposer<TSource, TContext> extends ObjectTypeComp
 
   DKeyETC: EnumTypeComposer<TContext>;
 
-  opts: DiscriminatorOptions<TContext>;
+  opts: ComposeWithMongooseDiscriminatorsOpts<TContext>;
 
   DInterface: InterfaceTypeComposer<TSource, TContext>;
 
@@ -190,6 +190,23 @@ export class DiscriminatorTypeComposer<TSource, TContext> extends ObjectTypeComp
     return !!this.childTCs.find(ch => ch.getTypeName() === DName);
   }
 
+  /* eslint no-use-before-define: 0 */
+  discriminator<TSrc: Model>(
+    childModel: Class<TSrc>,
+    opts?: ComposeWithMongooseOpts<TContext>
+  ): ObjectTypeComposer<TSrc, TContext> {
+    const customizationOpts = mergeCustomizationOptions((this.opts: any), opts);
+
+    let childTC = composeWithMongoose(childModel, customizationOpts);
+
+    childTC = composeChildTC(this, childTC, this.opts);
+
+    this.schemaComposer.addSchemaMustHaveType(childTC);
+    this.childTCs.push(childTC);
+
+    return childTC;
+  }
+
   setFields(fields: ComposeFieldConfigMap<any, any>): DiscriminatorTypeComposer<TSource, TContext> {
     const oldFieldNames = super.getFieldNames();
     super.setFields(fields);
@@ -358,21 +375,4 @@ export class DiscriminatorTypeComposer<TSource, TContext> extends ObjectTypeComp
 
     return this;
   }
-
-  /* eslint no-use-before-define: 0 */
-  discriminator<TSrc: Model>(
-    childModel: Class<TSrc>,
-    opts?: TypeConverterOpts<TContext>
-  ): ObjectTypeComposer<TSrc, TContext> {
-    const customizationOpts = mergeCustomizationOptions((this.opts: any), opts);
-
-    let childTC = composeWithMongoose(childModel, customizationOpts);
-
-    childTC = composeChildTC(this, childTC, this.opts);
-
-    this.schemaComposer.addSchemaMustHaveType(childTC);
-    this.childTCs.push(childTC);
-
-    return childTC;
-  }
 }

src/discriminators/composeChildTC.js

@@ -1,7 +1,10 @@
 /* @flow */
 
 import { ObjectTypeComposer } from 'graphql-compose';
-import type { DiscriminatorTypeComposer, DiscriminatorOptions } from './DiscriminatorTypeComposer';
+import type {
+  DiscriminatorTypeComposer,
+  ComposeWithMongooseDiscriminatorsOpts,
+} from './DiscriminatorTypeComposer';
 import { prepareChildResolvers } from './prepareChildResolvers';
 import { reorderFields } from './utils/reorderFields';
 
@@ -32,7 +35,7 @@ function copyBaseTCFieldsToChildTC(
 export function composeChildTC<TSource, TContext>(
   baseDTC: DiscriminatorTypeComposer<any, TContext>,
   childTC: ObjectTypeComposer<TSource, TContext>,
-  opts: DiscriminatorOptions<TContext>
+  opts: ComposeWithMongooseDiscriminatorsOpts<TContext>
 ): ObjectTypeComposer<TSource, TContext> {
   const composedChildTC = copyBaseTCFieldsToChildTC(baseDTC, childTC);
 

src/discriminators/index.d.ts

@@ -1,11 +1,6 @@
-import { TypeConverterOpts } from '../composeWithMongoose';
-
 export {
   DiscriminatorTypeComposer,
-  DiscriminatorOptions,
+  ComposeWithMongooseDiscriminatorsOpts,
 } from './DiscriminatorTypeComposer';
 
-export function mergeCustomizationOptions(
-  baseCOptions: TypeConverterOpts,
-  childCOptions?: TypeConverterOpts,
-): TypeConverterOpts | void;
+export { mergeCustomizationOptions } from './utils/mergeCustomizationOptions';

src/discriminators/index.js

@@ -1,4 +1,6 @@
 /* @flow */
 
-export { DiscriminatorTypeComposer, DiscriminatorOptions } from './DiscriminatorTypeComposer';
+export { DiscriminatorTypeComposer } from './DiscriminatorTypeComposer';
+export type { ComposeWithMongooseDiscriminatorsOpts } from './DiscriminatorTypeComposer';
+
 export { mergeCustomizationOptions } from './utils/mergeCustomizationOptions';

src/discriminators/prepareChildResolvers.js

@@ -2,7 +2,10 @@
 
 import type { ResolveParams } from 'graphql-compose';
 import { Resolver, ObjectTypeComposer } from 'graphql-compose';
-import { type DiscriminatorOptions, DiscriminatorTypeComposer } from './DiscriminatorTypeComposer';
+import {
+  type ComposeWithMongooseDiscriminatorsOpts,
+  DiscriminatorTypeComposer,
+} from './DiscriminatorTypeComposer';
 import { EMCResolvers } from '../resolvers';
 
 // set the DKey as a query on filter, also project it
@@ -134,7 +137,7 @@ function reorderFieldsRecordFilter<TSource, TContext>(
 export function prepareChildResolvers<TSource, TContext>(
   baseDTC: DiscriminatorTypeComposer<TSource, TContext>,
   childTC: ObjectTypeComposer<TSource, TContext>,
-  opts: DiscriminatorOptions<TContext>
+  opts: ComposeWithMongooseDiscriminatorsOpts<TContext>
 ) {
   for (const resolverName in EMCResolvers) {
     if (EMCResolvers.hasOwnProperty(resolverName) && childTC.hasResolver(resolverName)) {

src/discriminators/utils/__tests__/mergeCustomizationOptions-test.js

@@ -1,7 +1,7 @@
 /* @flow */
 
 import { SchemaComposer } from 'graphql-compose';
-import type { TypeConverterOpts } from '../../../composeWithMongoose';
+import type { ComposeWithMongooseOpts } from '../../../composeWithMongoose';
 import {
   mergeCustomizationOptions,
   mergeFieldMaps,
@@ -134,7 +134,7 @@ describe('mergeFieldMaps()', () => {
 });
 
 describe('mergeCustomizationOptions()', () => {
-  const baseCustomOptions: TypeConverterOpts<any> = {
+  const baseCustomOptions: ComposeWithMongooseOpts<any> = {
     fields: baseFields,
     inputType: {
       name: 'BaseInput',
@@ -170,7 +170,7 @@ describe('mergeCustomizationOptions()', () => {
     },
   };
 
-  const childCustomOptions: TypeConverterOpts<any> = {
+  const childCustomOptions: ComposeWithMongooseOpts<any> = {
     fields: childFields,
     inputType: {
       name: 'ChildInputs',
@@ -205,7 +205,7 @@ describe('mergeCustomizationOptions()', () => {
     },
   };
 
-  const expected: TypeConverterOpts<any> = {
+  const expected: ComposeWithMongooseOpts<any> = {
     fields: expectedFields,
     inputType: {
       name: 'ChildInputs',

src/discriminators/utils/mergeCustomizationOptions.d.ts

@@ -0,0 +1,24 @@
+/* @flow */
+
+import { ComposeWithMongooseOpts } from '../../composeWithMongoose';
+import { mergeTypeConverterResolverOpts } from './mergeTypeConverterResolversOpts';
+
+type FieldMap = {
+  [fieldName: string]: string[] | void;
+};
+
+export function mergeStringAndStringArraysFields(
+  baseField?: string[] | string,
+  childField?: string[] | string,
+  argOptsTypes?: string[] | string,
+): string[] | void;
+
+export function mergeFieldMaps(
+  baseFieldMap?: FieldMap,
+  childFieldMap?: FieldMap,
+): FieldMap | void;
+
+export function mergeCustomizationOptions<TContext>(
+  baseCOptions: ComposeWithMongooseOpts<TContext>,
+  childCOptions?: ComposeWithMongooseOpts<TContext>,
+): ComposeWithMongooseOpts<TContext> | void;

src/discriminators/utils/mergeCustomizationOptions.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-import type { TypeConverterOpts } from '../../composeWithMongoose';
+import type { ComposeWithMongooseOpts } from '../../composeWithMongoose';
 import { mergeTypeConverterResolverOpts } from './mergeTypeConverterResolversOpts';
 
 type FieldMap = {
@@ -10,7 +10,7 @@ type FieldMap = {
 export function mergeStringAndStringArraysFields(
   baseField?: string[] | string,
   childField?: string[] | string,
-  argOptsTypes: string[] | string
+  argOptsTypes?: string[] | string
 ): string[] | typeof undefined {
   if (Array.isArray(argOptsTypes)) {
     if (argOptsTypes.find(v => v === 'string' || v === 'string[]')) {
@@ -79,14 +79,14 @@ export function mergeFieldMaps(
 }
 
 export function mergeCustomizationOptions<TContext>(
-  baseCOptions: TypeConverterOpts<TContext>,
-  childCOptions?: TypeConverterOpts<TContext>
-): TypeConverterOpts<TContext> | void {
+  baseCOptions: ComposeWithMongooseOpts<TContext>,
+  childCOptions?: ComposeWithMongooseOpts<TContext>
+): ComposeWithMongooseOpts<TContext> | void {
   if (!baseCOptions) {
     return childCOptions;
   }
 
-  const mergedOptions: TypeConverterOpts<TContext> = childCOptions || ({}: any);
+  const mergedOptions: ComposeWithMongooseOpts<TContext> = childCOptions || ({}: any);
 
   if (
     baseCOptions.schemaComposer !== mergedOptions.schemaComposer &&

src/discriminators/utils/mergeTypeConverterResolversOpts.d.ts

@@ -0,0 +1,37 @@
+/* @flow */
+
+import { TypeConverterResolversOpts } from '../../composeWithMongoose';
+import { MergeAbleHelperArgsOpts } from '../../resolvers/helpers';
+import { mergeStringAndStringArraysFields } from './mergeCustomizationOptions';
+
+type TypeFieldMap = {
+  [fieldName: string]: any;
+};
+
+export function mergePrimitiveTypeFields(
+  baseField?: any,
+  childField?: any,
+  argOptsTypes?: string[] | string,
+): any;
+
+export function mergeFilterOperatorsOptsMap(
+  baseFilterOperatorField: TypeFieldMap,
+  childFilterOperatorField?: TypeFieldMap,
+): TypeFieldMap;
+
+export function mergeArraysTypeFields(
+  baseField: any,
+  childField: any,
+  argOptsType: TypeFieldMap,
+): {};
+
+export function mergeMapTypeFields(
+  baseField: any,
+  childField: any,
+  argOptsTypes: TypeFieldMap,
+): {};
+
+export function mergeTypeConverterResolverOpts(
+  baseTypeConverterResolverOpts?: TypeConverterResolversOpts | false,
+  childTypeConverterResolverOpts?: TypeConverterResolversOpts | false,
+): TypeConverterResolversOpts | false | void;