feat: expose toInputType() method which converts AnyComposeType to InputType. Scalars, Enums, Inputs will be returned without changes. Object, Interfaces – converted to Input. Unions – throw an Error. Type may be wrapped with modifiers NonNull, List.

Author: nodkz

src/InterfaceTypeComposer.js

@@ -41,7 +41,7 @@ import type {
   DirectiveArgs,
   ExtensionsDirective,
 } from './utils/definitions';
-import { toInputObjectType } from './utils/toInputObjectType';
+import { toInputObjectType } from './utils/toInputType';
 import { typeByPath, type TypeInPath } from './utils/typeByPath';
 import {
   getComposeTypeName,

src/ObjectTypeComposer.js

@@ -40,7 +40,7 @@ import {
   convertObjectFieldMapToConfig,
   convertInterfaceArrayAsThunk,
 } from './utils/configToDefine';
-import { toInputObjectType } from './utils/toInputObjectType';
+import { toInputObjectType } from './utils/toInputType';
 import { typeByPath, type TypeInPath } from './utils/typeByPath';
 import {
   getComposeTypeName,

src/index.d.ts

@@ -30,7 +30,7 @@ export { GraphQLDate, GraphQLBuffer, GraphQLJSON, GraphQLJSONObject } from './ty
 
 // Utils
 export { getProjectionFromAST, getFlatProjectionFromAST } from './utils/projection';
-export { toInputObjectType, ConvertInputObjectFieldOpts } from './utils/toInputObjectType';
+export { toInputType, toInputObjectType, convertInputObjectField } from './utils/toInputType';
 export * from './utils/misc';
 export * from './utils/typeHelpers';
 export * from './utils/is';

src/index.js

@@ -5,9 +5,7 @@ import { SchemaComposer } from './SchemaComposer';
 
 export { graphql };
 
-type TContext = any;
-
-const schemaComposer = new SchemaComposer<TContext>();
+const schemaComposer = new SchemaComposer<any>();
 const sc = schemaComposer;
 export {
   SchemaComposer, // SchemaComposer class
@@ -34,7 +32,7 @@ export { GraphQLDate, GraphQLBuffer, GraphQLJSON, GraphQLJSONObject } from './ty
 
 // Utils
 export { getProjectionFromAST, getFlatProjectionFromAST } from './utils/projection';
-export { toInputObjectType, convertInputObjectField } from './utils/toInputObjectType';
+export { toInputType, toInputObjectType, convertInputObjectField } from './utils/toInputType';
 export * from './utils/misc';
 export * from './utils/typeHelpers';
 export * from './utils/is';

src/utils/__tests__/toInputObjectType-test.js renamed to src/utils/__tests__/toInputType-test.js

@@ -11,7 +11,55 @@ import { schemaComposer as sc } from '../..';
 import { ObjectTypeComposer } from '../../ObjectTypeComposer';
 import { InputTypeComposer } from '../../InputTypeComposer';
 import { InterfaceTypeComposer } from '../../InterfaceTypeComposer';
-import { toInputObjectType } from '../toInputObjectType';
+import { toInputObjectType, toInputType } from '../toInputType';
+
+describe('toInputType()', () => {
+  beforeEach(() => {
+    sc.clear();
+  });
+
+  it('should return Scalar, Enum, Input types unchanged', () => {
+    const stc = sc.createScalarTC('MyScalar');
+    const itc1 = toInputType(stc);
+    expect(itc1).toBe(stc);
+
+    const etc = sc.createEnumTC('MyEnum');
+    const itc2 = toInputType(etc);
+    expect(itc2).toBe(etc);
+
+    const itc = sc.createInputTC('MyInput');
+    const itc3 = toInputType(itc);
+    expect(itc3).toBe(itc);
+  });
+
+  it('should return wrapped Scalar, Enum Input types unchanged', () => {
+    const stc = sc.createScalarTC('MyScalar').List.NonNull;
+    const itc1 = toInputType(stc);
+    expect(itc1.getTypeName()).toBe('[MyScalar]!');
+    expect((itc1: any).ofType.ofType).toBe((stc: any).ofType.ofType);
+
+    const etc = sc.createEnumTC('MyEnum').NonNull;
+    const itc2 = toInputType(etc);
+    expect(itc2.getTypeName()).toBe('MyEnum!');
+    expect((itc2: any).ofType).toBe((etc: any).ofType);
+
+    const itc = sc.createScalarTC('MyInput').NonNull.List.NonNull;
+    const itc3 = toInputType(itc);
+    expect(itc3.getTypeName()).toBe('[MyInput!]!');
+    expect((itc3: any).ofType.ofType.ofType).toBe((itc: any).ofType.ofType.ofType);
+  });
+
+  it('should convert wrapped Object type to new Input type', () => {
+    const otc = sc.createObjectTC({
+      name: 'MyObject',
+      fields: { a: 'Int', b: 'Float!' },
+    }).NonNull;
+    const itc = toInputType(otc);
+    expect(itc.getTypeName()).toBe('MyObjectInput!');
+    expect((itc: any).ofType.getFieldTypeName('a')).toBe('Int');
+    expect((itc: any).ofType.getFieldTypeName('b')).toBe('Float!');
+  });
+});
 
 describe('toInputObjectType()', () => {
   let PersonTC: ObjectTypeComposer<any, any>;

src/utils/toInputObjectType.d.ts

@@ -0,0 +1,42 @@
+import { InputTypeComposer } from '../InputTypeComposer';
+import { ObjectTypeComposer } from '../ObjectTypeComposer';
+import { InterfaceTypeComposer } from '../InterfaceTypeComposer';
+import { SchemaComposer } from '../SchemaComposer';
+import { AnyTypeComposer, ComposeOutputType, ComposeInputType } from './typeHelpers';
+
+export interface ToInputTypeOpts {
+  /** If ObjectType or Interface received then will be used `${prefix}ObjectTypeName` as name for new Input type */
+  prefix?: string;
+  /** If ObjectType or Interface received then will be used `ObjectTypeName${suffix}` as name for new Input type */
+  postfix?: string;
+  /** When Union type is met then Error will be throw. This option helps to return provided fallbackType instead of Error. */
+  fallbackType?: ComposeInputType;
+}
+
+/**
+ * Convert any TypeComposer to InputType.
+ *
+ * Type may be wrapped with modifiers NonNull, List.
+ *
+ * Scalars and Input types returned without changes.
+ *
+ * ObjectTypeComposer & InterfaceTypeComposer converted to InputTypeComposer
+ * under name `{ObjectTypeName}Input`. Prefix & suffix can be overridden via opts.
+ *
+ * UnionTypeComposer throws Error, if opts?.fallbackType is not provided.
+ */
+export function toInputType(anyTC: AnyTypeComposer<any>, opts?: ToInputTypeOpts): ComposeInputType;
+
+/**
+ * Convert ObjectTypeComposer or InterfaceTypeComposer to InputTypeComposer.
+ * Also will be converted all Object types which are used for fields.
+ */
+export function toInputObjectType<TContext>(
+  tc: ObjectTypeComposer<any, TContext> | InterfaceTypeComposer<any, TContext>,
+  opts?: ToInputTypeOpts
+): InputTypeComposer<TContext>;
+
+export function convertInputObjectField(
+  field: ComposeOutputType<any>,
+  opts: ToInputTypeOpts
+): ComposeInputType | null;