@khanacademy/graphql-flow 0.3.0 → 1.0.0

package/dist/generateResponseType.js

@@ -21,15 +21,15 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 /* eslint-disable no-console */
 // eslint-disable-line flowtype-errors/uncovered
-const generateResponseType = (schema, query, config) => {
-  const ast = querySelectionToObjectType(config, query.selectionSet.selections, query.operation === 'mutation' ? schema.typesByName.Mutation : schema.typesByName.Query, query.operation === 'mutation' ? 'mutation' : 'query'); // eslint-disable-next-line flowtype-errors/uncovered
+const generateResponseType = (schema, query, ctx) => {
+  const ast = querySelectionToObjectType(ctx, query.selectionSet.selections, query.operation === 'mutation' ? schema.typesByName.Mutation : schema.typesByName.Query, query.operation === 'mutation' ? 'mutation' : 'query'); // eslint-disable-next-line flowtype-errors/uncovered
 
   return (0, _generator.default)(ast).code;
 };
 
 exports.generateResponseType = generateResponseType;
 
-const sortedObjectTypeAnnotation = (config, properties) => {
+const sortedObjectTypeAnnotation = (ctx, properties) => {
   const obj = babelTypes.objectTypeAnnotation(properties.sort((a, b) => {
     if (a.type === 'ObjectTypeProperty' && b.type === 'ObjectTypeProperty') {
       const aName = a.key.type === 'Identifier' ? a.key.name : '';
@@ -47,27 +47,27 @@ const sortedObjectTypeAnnotation = (config, properties) => {
   , true
   /* exact */
   );
-  const name = config.path.join('_');
-  const isTopLevelType = config.path.length <= 1;
+  const name = ctx.path.join('_');
+  const isTopLevelType = ctx.path.length <= 1;
 
-  if (config.allObjectTypes != null && !isTopLevelType) {
-    config.allObjectTypes[name] = obj;
+  if (ctx.allObjectTypes != null && !isTopLevelType) {
+    ctx.allObjectTypes[name] = obj;
     return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
   } else {
     return obj;
   }
 };
 
-const generateFragmentType = (schema, fragment, config) => {
+const generateFragmentType = (schema, fragment, ctx) => {
   const onType = fragment.typeCondition.name.value;
   let ast;
 
   if (schema.typesByName[onType]) {
-    ast = sortedObjectTypeAnnotation(config, objectPropertiesToFlow(config, schema.typesByName[onType], onType, fragment.selectionSet.selections));
+    ast = sortedObjectTypeAnnotation(ctx, objectPropertiesToFlow(ctx, schema.typesByName[onType], onType, fragment.selectionSet.selections));
   } else if (schema.interfacesByName[onType]) {
-    ast = unionOrInterfaceToFlow(config, config.schema.interfacesByName[onType], fragment.selectionSet.selections);
+    ast = unionOrInterfaceToFlow(ctx, ctx.schema.interfacesByName[onType], fragment.selectionSet.selections);
   } else if (schema.unionsByName[onType]) {
-    ast = unionOrInterfaceToFlow(config, config.schema.unionsByName[onType], fragment.selectionSet.selections);
+    ast = unionOrInterfaceToFlow(ctx, ctx.schema.unionsByName[onType], fragment.selectionSet.selections);
   } else {
     throw new Error(`Unknown ${onType}`);
   } // eslint-disable-next-line flowtype-errors/uncovered
@@ -78,24 +78,24 @@ const generateFragmentType = (schema, fragment, config) => {
 
 exports.generateFragmentType = generateFragmentType;
 
-const _typeToFlow = (config, type, selection) => {
+const _typeToFlow = (ctx, type, selection) => {
   if (type.kind === 'SCALAR') {
-    return (0, _enums.scalarTypeToFlow)(config, type.name);
+    return (0, _enums.scalarTypeToFlow)(ctx, type.name);
   }
 
   if (type.kind === 'LIST') {
-    return babelTypes.genericTypeAnnotation(config.readOnlyArray ? babelTypes.identifier('$ReadOnlyArray') : babelTypes.identifier('Array'), babelTypes.typeParameterInstantiation([typeToFlow(config, type.ofType, selection)]));
+    return babelTypes.genericTypeAnnotation(ctx.readOnlyArray ? babelTypes.identifier('$ReadOnlyArray') : babelTypes.identifier('Array'), babelTypes.typeParameterInstantiation([typeToFlow(ctx, type.ofType, selection)]));
   }
 
   if (type.kind === 'UNION') {
-    const union = config.schema.unionsByName[type.name];
+    const union = ctx.schema.unionsByName[type.name];
 
     if (!selection.selectionSet) {
       console.log('no selection set', selection);
       return babelTypes.anyTypeAnnotation();
     }
 
-    return unionOrInterfaceToFlow(config, union, selection.selectionSet.selections);
+    return unionOrInterfaceToFlow(ctx, union, selection.selectionSet.selections);
   }
 
   if (type.kind === 'INTERFACE') {
@@ -104,11 +104,11 @@ const _typeToFlow = (config, type, selection) => {
       return babelTypes.anyTypeAnnotation();
     }
 
-    return unionOrInterfaceToFlow(config, config.schema.interfacesByName[type.name], selection.selectionSet.selections);
+    return unionOrInterfaceToFlow(ctx, ctx.schema.interfacesByName[type.name], selection.selectionSet.selections);
   }
 
   if (type.kind === 'ENUM') {
-    return (0, _enums.enumTypeToFlow)(config, type.name);
+    return (0, _enums.enumTypeToFlow)(ctx, type.name);
   }
 
   if (type.kind !== 'OBJECT') {
@@ -118,33 +118,33 @@ const _typeToFlow = (config, type, selection) => {
 
   const tname = type.name;
 
-  if (!config.schema.typesByName[tname]) {
+  if (!ctx.schema.typesByName[tname]) {
     console.log('unknown referenced type', tname);
     return babelTypes.anyTypeAnnotation();
   }
 
-  const childType = config.schema.typesByName[tname];
+  const childType = ctx.schema.typesByName[tname];
 
   if (!selection.selectionSet) {
     console.log('no selection set', selection);
     return babelTypes.anyTypeAnnotation();
   }
 
-  return (0, _utils.maybeAddDescriptionComment)(childType.description, querySelectionToObjectType(config, selection.selectionSet.selections, childType, tname));
+  return (0, _utils.maybeAddDescriptionComment)(childType.description, querySelectionToObjectType(ctx, selection.selectionSet.selections, childType, tname));
 };
 
-const typeToFlow = (config, type, selection) => {
+const typeToFlow = (ctx, type, selection) => {
   // throw new Error('npoe');
   if (type.kind === 'NON_NULL') {
-    return _typeToFlow(config, type.ofType, selection);
+    return _typeToFlow(ctx, type.ofType, selection);
   } // If we don'babelTypes care about strict nullability checking, then pretend everything is non-null
 
 
-  if (!config.strictNullability) {
-    return _typeToFlow(config, type, selection);
+  if (!ctx.strictNullability) {
+    return _typeToFlow(ctx, type, selection);
   }
 
-  const inner = _typeToFlow(config, type, selection);
+  const inner = _typeToFlow(ctx, type, selection);
 
   const result = babelTypes.nullableTypeAnnotation(inner);
   return (0, _utils.transferLeadingComments)(inner, result);
@@ -176,11 +176,11 @@ const ensureOnlyOneTypenameProperty = properties => {
   });
 };
 
-const querySelectionToObjectType = (config, selections, type, typeName) => {
-  return sortedObjectTypeAnnotation(config, ensureOnlyOneTypenameProperty(objectPropertiesToFlow(config, type, typeName, selections)));
+const querySelectionToObjectType = (ctx, selections, type, typeName) => {
+  return sortedObjectTypeAnnotation(ctx, ensureOnlyOneTypenameProperty(objectPropertiesToFlow(ctx, type, typeName, selections)));
 };
 
-const objectPropertiesToFlow = (config, type, typeName, selections) => {
+const objectPropertiesToFlow = (ctx, type, typeName, selections) => {
   return [].concat(...selections.map(selection => {
     switch (selection.kind) {
       case 'InlineFragment':
@@ -193,16 +193,16 @@ const objectPropertiesToFlow = (config, type, typeName, selections) => {
             return [];
           }
 
-          return objectPropertiesToFlow(config, config.schema.typesByName[newTypeName], newTypeName, selection.selectionSet.selections);
+          return objectPropertiesToFlow(ctx, ctx.schema.typesByName[newTypeName], newTypeName, selection.selectionSet.selections);
         }
 
       case 'FragmentSpread':
-        if (!config.fragments[selection.name.value]) {
-          config.errors.push(`No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`);
+        if (!ctx.fragments[selection.name.value]) {
+          ctx.errors.push(`No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`);
           return [babelTypes.objectTypeProperty(babelTypes.identifier(selection.name.value), babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_FRAGMENT`)))];
         }
 
-        return objectPropertiesToFlow(config, type, typeName, config.fragments[selection.name.value].selectionSet.selections);
+        return objectPropertiesToFlow(ctx, type, typeName, ctx.fragments[selection.name.value].selectionSet.selections);
 
       case 'Field':
         const name = selection.name.value;
@@ -213,17 +213,17 @@ const objectPropertiesToFlow = (config, type, typeName, selections) => {
         }
 
         if (!type.fieldsByName[name]) {
-          config.errors.push(`Unknown field '${name}' for type '${typeName}'`);
+          ctx.errors.push(`Unknown field '${name}' for type '${typeName}'`);
           return babelTypes.objectTypeProperty(babelTypes.identifier(alias), babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_FIELD["${name}"]`)));
         }
 
         const typeField = type.fieldsByName[name];
-        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow({ ...config,
-          path: config.path.concat([alias])
+        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow({ ...ctx,
+          path: ctx.path.concat([alias])
         }, typeField.type, selection))))];
 
       default:
-        config.errors.push( // eslint-disable-next-line flowtype-errors/uncovered
+        ctx.errors.push( // eslint-disable-next-line flowtype-errors/uncovered
         `Unsupported selection kind '${selection.kind}'`);
         return [];
     }
@@ -232,13 +232,13 @@ const objectPropertiesToFlow = (config, type, typeName, selections) => {
 
 exports.objectPropertiesToFlow = objectPropertiesToFlow;
 
-const unionOrInterfaceToFlow = (config, type, selections) => {
+const unionOrInterfaceToFlow = (ctx, type, selections) => {
   const allFields = selections.every(selection => selection.kind === 'Field');
   const selectedAttributes = type.possibleTypes.slice().sort((a, b) => {
     return a.name < b.name ? -1 : 1;
   }).map(possible => {
-    const configWithUpdatedPath = { ...config,
-      path: allFields ? config.path : config.path.concat([possible.name])
+    const configWithUpdatedPath = { ...ctx,
+      path: allFields ? ctx.path : ctx.path.concat([possible.name])
     };
     return {
       typeName: possible.name,
@@ -255,11 +255,11 @@ const unionOrInterfaceToFlow = (config, type, selections) => {
       attrs.attributes[typeNameIndex].value)));
     }
 
-    return sortedObjectTypeAnnotation(config, sharedAttributes);
+    return sortedObjectTypeAnnotation(ctx, sharedAttributes);
   }
 
   if (selectedAttributes.length === 1) {
-    return sortedObjectTypeAnnotation(config, selectedAttributes[0].attributes);
+    return sortedObjectTypeAnnotation(ctx, selectedAttributes[0].attributes);
   }
   /**
    * When generating the objects for the sub-options of a union, the path needs
@@ -296,13 +296,13 @@ const unionOrInterfaceToFlow = (config, type, selections) => {
   const result = babelTypes.unionTypeAnnotation(selectedAttributes.map(({
     typeName,
     attributes
-  }) => sortedObjectTypeAnnotation({ ...config,
-    path: config.path.concat([typeName])
+  }) => sortedObjectTypeAnnotation({ ...ctx,
+    path: ctx.path.concat([typeName])
   }, attributes)));
-  const name = config.path.join('_');
+  const name = ctx.path.join('_');
 
-  if (config.allObjectTypes && config.path.length > 1) {
-    config.allObjectTypes[name] = result;
+  if (ctx.allObjectTypes && ctx.path.length > 1) {
+    ctx.allObjectTypes[name] = result;
     return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
   }
 

package/dist/generateResponseType.js.flow

@@ -9,7 +9,7 @@ import type {
     OperationDefinitionNode,
     FragmentDefinitionNode,
 } from 'graphql';
-import type {Config, Schema, Selections} from './types';
+import type {Context, Schema, Selections} from './types';
 import {
     liftLeadingPropertyComments,
     maybeAddDescriptionComment,
@@ -30,10 +30,10 @@ import {
 export const generateResponseType = (
     schema: Schema,
     query: OperationDefinitionNode,
-    config: Config,
+    ctx: Context,
 ): string => {
     const ast = querySelectionToObjectType(
-        config,
+        ctx,
         query.selectionSet.selections,
         query.operation === 'mutation'
             ? schema.typesByName.Mutation
@@ -45,7 +45,7 @@ export const generateResponseType = (
 };
 
 const sortedObjectTypeAnnotation = (
-    config: Config,
+    ctx: Context,
     properties: Array<
         BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty,
     >,
@@ -67,10 +67,10 @@ const sortedObjectTypeAnnotation = (
         undefined /* internalSlots */,
         true /* exact */,
     );
-    const name = config.path.join('_');
-    const isTopLevelType = config.path.length <= 1;
-    if (config.allObjectTypes != null && !isTopLevelType) {
-        config.allObjectTypes[name] = obj;
+    const name = ctx.path.join('_');
+    const isTopLevelType = ctx.path.length <= 1;
+    if (ctx.allObjectTypes != null && !isTopLevelType) {
+        ctx.allObjectTypes[name] = obj;
         return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
     } else {
         return obj;
@@ -80,16 +80,16 @@ const sortedObjectTypeAnnotation = (
 export const generateFragmentType = (
     schema: Schema,
     fragment: FragmentDefinitionNode,
-    config: Config,
+    ctx: Context,
 ): string => {
     const onType = fragment.typeCondition.name.value;
     let ast;
 
     if (schema.typesByName[onType]) {
         ast = sortedObjectTypeAnnotation(
-            config,
+            ctx,
             objectPropertiesToFlow(
-                config,
+                ctx,
                 schema.typesByName[onType],
                 onType,
                 fragment.selectionSet.selections,
@@ -97,14 +97,14 @@ export const generateFragmentType = (
         );
     } else if (schema.interfacesByName[onType]) {
         ast = unionOrInterfaceToFlow(
-            config,
-            config.schema.interfacesByName[onType],
+            ctx,
+            ctx.schema.interfacesByName[onType],
             fragment.selectionSet.selections,
         );
     } else if (schema.unionsByName[onType]) {
         ast = unionOrInterfaceToFlow(
-            config,
-            config.schema.unionsByName[onType],
+            ctx,
+            ctx.schema.unionsByName[onType],
             fragment.selectionSet.selections,
         );
     } else {
@@ -116,31 +116,31 @@ export const generateFragmentType = (
 };
 
 const _typeToFlow = (
-    config: Config,
+    ctx: Context,
     type,
     selection,
 ): babelTypes.BabelNodeFlowType => {
     if (type.kind === 'SCALAR') {
-        return scalarTypeToFlow(config, type.name);
+        return scalarTypeToFlow(ctx, type.name);
     }
     if (type.kind === 'LIST') {
         return babelTypes.genericTypeAnnotation(
-            config.readOnlyArray
+            ctx.readOnlyArray
                 ? babelTypes.identifier('$ReadOnlyArray')
                 : babelTypes.identifier('Array'),
             babelTypes.typeParameterInstantiation([
-                typeToFlow(config, type.ofType, selection),
+                typeToFlow(ctx, type.ofType, selection),
             ]),
         );
     }
     if (type.kind === 'UNION') {
-        const union = config.schema.unionsByName[type.name];
+        const union = ctx.schema.unionsByName[type.name];
         if (!selection.selectionSet) {
             console.log('no selection set', selection);
             return babelTypes.anyTypeAnnotation();
         }
         return unionOrInterfaceToFlow(
-            config,
+            ctx,
             union,
             selection.selectionSet.selections,
         );
@@ -152,13 +152,13 @@ const _typeToFlow = (
             return babelTypes.anyTypeAnnotation();
         }
         return unionOrInterfaceToFlow(
-            config,
-            config.schema.interfacesByName[type.name],
+            ctx,
+            ctx.schema.interfacesByName[type.name],
             selection.selectionSet.selections,
         );
     }
     if (type.kind === 'ENUM') {
-        return enumTypeToFlow(config, type.name);
+        return enumTypeToFlow(ctx, type.name);
     }
     if (type.kind !== 'OBJECT') {
         console.log('not object', type);
@@ -166,11 +166,11 @@ const _typeToFlow = (
     }
 
     const tname = type.name;
-    if (!config.schema.typesByName[tname]) {
+    if (!ctx.schema.typesByName[tname]) {
         console.log('unknown referenced type', tname);
         return babelTypes.anyTypeAnnotation();
     }
-    const childType = config.schema.typesByName[tname];
+    const childType = ctx.schema.typesByName[tname];
     if (!selection.selectionSet) {
         console.log('no selection set', selection);
         return babelTypes.anyTypeAnnotation();
@@ -178,7 +178,7 @@ const _typeToFlow = (
     return maybeAddDescriptionComment(
         childType.description,
         querySelectionToObjectType(
-            config,
+            ctx,
             selection.selectionSet.selections,
             childType,
             tname,
@@ -187,19 +187,19 @@ const _typeToFlow = (
 };
 
 export const typeToFlow = (
-    config: Config,
+    ctx: Context,
     type: IntrospectionOutputTypeRef,
     selection: FieldNode,
 ): babelTypes.BabelNodeFlowType => {
     // throw new Error('npoe');
     if (type.kind === 'NON_NULL') {
-        return _typeToFlow(config, type.ofType, selection);
+        return _typeToFlow(ctx, type.ofType, selection);
     }
     // If we don'babelTypes care about strict nullability checking, then pretend everything is non-null
-    if (!config.strictNullability) {
-        return _typeToFlow(config, type, selection);
+    if (!ctx.strictNullability) {
+        return _typeToFlow(ctx, type, selection);
     }
-    const inner = _typeToFlow(config, type, selection);
+    const inner = _typeToFlow(ctx, type, selection);
     const result = babelTypes.nullableTypeAnnotation(inner);
     return transferLeadingComments(inner, result);
 };
@@ -233,21 +233,21 @@ const ensureOnlyOneTypenameProperty = (properties) => {
 };
 
 const querySelectionToObjectType = (
-    config: Config,
+    ctx: Context,
     selections,
     type,
     typeName: string,
 ): BabelNodeFlowType => {
     return sortedObjectTypeAnnotation(
-        config,
+        ctx,
         ensureOnlyOneTypenameProperty(
-            objectPropertiesToFlow(config, type, typeName, selections),
+            objectPropertiesToFlow(ctx, type, typeName, selections),
         ),
     );
 };
 
 export const objectPropertiesToFlow = (
-    config: Config,
+    ctx: Context,
     type: IntrospectionObjectType & {
         fieldsByName: {[name: string]: IntrospectionField},
     },
@@ -264,15 +264,15 @@ export const objectPropertiesToFlow = (
                         return [];
                     }
                     return objectPropertiesToFlow(
-                        config,
-                        config.schema.typesByName[newTypeName],
+                        ctx,
+                        ctx.schema.typesByName[newTypeName],
                         newTypeName,
                         selection.selectionSet.selections,
                     );
                 }
                 case 'FragmentSpread':
-                    if (!config.fragments[selection.name.value]) {
-                        config.errors.push(
+                    if (!ctx.fragments[selection.name.value]) {
+                        ctx.errors.push(
                             `No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`,
                         );
                         return [
@@ -286,10 +286,10 @@ export const objectPropertiesToFlow = (
                     }
 
                     return objectPropertiesToFlow(
-                        config,
+                        ctx,
                         type,
                         typeName,
-                        config.fragments[selection.name.value].selectionSet
+                        ctx.fragments[selection.name.value].selectionSet
                             .selections,
                     );
 
@@ -309,7 +309,7 @@ export const objectPropertiesToFlow = (
                         ];
                     }
                     if (!type.fieldsByName[name]) {
-                        config.errors.push(
+                        ctx.errors.push(
                             `Unknown field '${name}' for type '${typeName}'`,
                         );
                         return babelTypes.objectTypeProperty(
@@ -331,8 +331,8 @@ export const objectPropertiesToFlow = (
                                     babelTypes.identifier(alias),
                                     typeToFlow(
                                         {
-                                            ...config,
-                                            path: config.path.concat([alias]),
+                                            ...ctx,
+                                            path: ctx.path.concat([alias]),
                                         },
                                         typeField.type,
                                         selection,
@@ -343,7 +343,7 @@ export const objectPropertiesToFlow = (
                     ];
 
                 default:
-                    config.errors.push(
+                    ctx.errors.push(
                         // eslint-disable-next-line flowtype-errors/uncovered
                         `Unsupported selection kind '${selection.kind}'`,
                     );
@@ -354,7 +354,7 @@ export const objectPropertiesToFlow = (
 };
 
 export const unionOrInterfaceToFlow = (
-    config: Config,
+    ctx: Context,
     type:
         | IntrospectionUnionType
         | (IntrospectionInterfaceType & {
@@ -377,10 +377,8 @@ export const unionOrInterfaceToFlow = (
         })
         .map((possible) => {
             const configWithUpdatedPath = {
-                ...config,
-                path: allFields
-                    ? config.path
-                    : config.path.concat([possible.name]),
+                ...ctx,
+                path: allFields ? ctx.path : ctx.path.concat([possible.name]),
             };
             return {
                 typeName: possible.name,
@@ -421,11 +419,11 @@ export const unionOrInterfaceToFlow = (
                 ),
             );
         }
-        return sortedObjectTypeAnnotation(config, sharedAttributes);
+        return sortedObjectTypeAnnotation(ctx, sharedAttributes);
     }
     if (selectedAttributes.length === 1) {
         return sortedObjectTypeAnnotation(
-            config,
+            ctx,
             selectedAttributes[0].attributes,
         );
     }
@@ -462,14 +460,14 @@ export const unionOrInterfaceToFlow = (
     const result = babelTypes.unionTypeAnnotation(
         selectedAttributes.map(({typeName, attributes}) =>
             sortedObjectTypeAnnotation(
-                {...config, path: config.path.concat([typeName])},
+                {...ctx, path: ctx.path.concat([typeName])},
                 attributes,
             ),
         ),
     );
-    const name = config.path.join('_');
-    if (config.allObjectTypes && config.path.length > 1) {
-        config.allObjectTypes[name] = result;
+    const name = ctx.path.join('_');
+    if (ctx.allObjectTypes && ctx.path.length > 1) {
+        ctx.allObjectTypes[name] = result;
         return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
     }
     return result;