@khanacademy/graphql-flow 0.2.4 → 1.0.0

package/src/enums.js

@@ -3,15 +3,41 @@
  * Both input & output types can have enums & scalars.
  */
 import * as babelTypes from '@babel/types';
-import {type BabelNodeFlowType} from '@babel/types';
-import type {Config} from './types';
+import type {BabelNodeFlowType} from '@babel/types';
+import type {Context} from './types';
 import {maybeAddDescriptionComment} from './utils';
+import type {IntrospectionEnumType} from 'graphql/utilities/introspectionQuery';
+
+export const experimentalEnumTypeToFlow = (
+    ctx: Context,
+    enumConfig: IntrospectionEnumType,
+    description: string,
+): BabelNodeFlowType => {
+    const enumDeclaration = babelTypes.enumDeclaration(
+        // pass id into generic type annotation
+        babelTypes.identifier(enumConfig.name),
+        babelTypes.enumStringBody(
+            enumConfig.enumValues.map((v) =>
+                babelTypes.enumDefaultedMember(babelTypes.identifier(v.name)),
+            ),
+        ),
+    );
+
+    if (ctx.experimentalEnumsMap) {
+        ctx.experimentalEnumsMap[enumConfig.name] = enumDeclaration;
+    }
+
+    return maybeAddDescriptionComment(
+        description,
+        babelTypes.genericTypeAnnotation(enumDeclaration.id),
+    );
+};
 
 export const enumTypeToFlow = (
-    config: Config,
+    ctx: Context,
     name: string,
 ): BabelNodeFlowType => {
-    const enumConfig = config.schema.enumsByName[name];
+    const enumConfig = ctx.schema.enumsByName[name];
     let combinedDescription = enumConfig.enumValues
         .map(
             (n) =>
@@ -25,14 +51,17 @@ export const enumTypeToFlow = (
         combinedDescription =
             enumConfig.description + '\n\n' + combinedDescription;
     }
-    return maybeAddDescriptionComment(
-        combinedDescription,
-        babelTypes.unionTypeAnnotation(
-            enumConfig.enumValues.map((n) =>
-                babelTypes.stringLiteralTypeAnnotation(n.name),
-            ),
-        ),
-    );
+
+    return ctx.experimentalEnumsMap
+        ? experimentalEnumTypeToFlow(ctx, enumConfig, combinedDescription)
+        : maybeAddDescriptionComment(
+              combinedDescription,
+              babelTypes.unionTypeAnnotation(
+                  enumConfig.enumValues.map((n) =>
+                      babelTypes.stringLiteralTypeAnnotation(n.name),
+                  ),
+              ),
+          );
 };
 
 export const builtinScalars: {[key: string]: string} = {
@@ -46,7 +75,7 @@ export const builtinScalars: {[key: string]: string} = {
 };
 
 export const scalarTypeToFlow = (
-    config: Config,
+    ctx: Context,
     name: string,
 ): BabelNodeFlowType => {
     if (builtinScalars[name]) {
@@ -54,13 +83,13 @@ export const scalarTypeToFlow = (
             babelTypes.identifier(builtinScalars[name]),
         );
     }
-    const underlyingType = config.scalars[name];
+    const underlyingType = ctx.scalars[name];
     if (underlyingType != null) {
         return babelTypes.genericTypeAnnotation(
             babelTypes.identifier(underlyingType),
         );
     }
-    config.errors.push(
+    ctx.errors.push(
         `Unexpected scalar '${name}'! Please add it to the "scalars" argument at the callsite of 'generateFlowTypes()'.`,
     );
     return babelTypes.genericTypeAnnotation(

package/src/generateResponseType.js

@@ -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;

package/src/generateTypeFiles.js

@@ -1,28 +1,10 @@
 // @flow
-// Import this in your jest setup, to mock out graphql-tag!
 import type {DocumentNode} from 'graphql';
-import type {Options, Schema, Scalars} from './types';
+import type {GenerateConfig, CrawlConfig, Schema} from './types';
 import fs from 'fs';
 import path from 'path';
 import {documentToFlowTypes} from '.';
 
-export type ExternalOptions = {
-    pragma?: string,
-    loosePragma?: string,
-    ignorePragma?: string,
-    scalars?: Scalars,
-    strictNullability?: boolean,
-    /**
-     * The command that users should run to regenerate the types files.
-     */
-    regenerateCommand?: string,
-    readOnlyArray?: boolean,
-    splitTypes?: boolean,
-    generatedDirectory?: string,
-    exportAllObjectTypes?: boolean,
-    typeFileName?: string,
-};
-
 export const indexPrelude = (regenerateCommand?: string): string => `// @flow
 //
 // AUTOGENERATED
@@ -37,7 +19,7 @@ export const generateTypeFileContents = (
     fileName: string,
     schema: Schema,
     document: DocumentNode,
-    options: Options,
+    options: GenerateConfig,
     generatedDir: string,
     indexContents: string,
 ): {indexContents: string, files: {[key: string]: string}} => {
@@ -62,54 +44,82 @@ export const generateTypeFileContents = (
     };
 
     const generated = documentToFlowTypes(document, schema, options);
-    generated.forEach(({name, typeName, code, isFragment, extraTypes}) => {
-        // We write all generated files to a `__generated__` subdir to keep
-        // things tidy.
-        const targetFileName = options.typeFileName
-            ? options.typeFileName.replace('[operationName]', name)
-            : `${name}.js`;
-        const targetPath = path.join(generatedDir, targetFileName);
-
-        let fileContents =
-            '// @' +
-            `flow\n// AUTOGENERATED -- DO NOT EDIT\n` +
-            `// Generated for operation '${name}' in file '../${path.basename(
-                fileName,
-            )}'\n` +
-            (options.regenerateCommand
-                ? `// To regenerate, run '${options.regenerateCommand}'.\n`
-                : '') +
-            code;
-        if (options.splitTypes && !isFragment) {
-            fileContents +=
-                `\nexport type ${name} = ${typeName}['response'];\n` +
-                `export type ${name}Variables = ${typeName}['variables'];\n`;
-        }
-        Object.keys(extraTypes).forEach((name) => {
-            fileContents += `\n\nexport type ${name} = ${extraTypes[name]};`;
-        });
-
-        addToIndex(targetPath, typeName);
-        files[targetPath] =
-            fileContents
-                // Remove whitespace from the ends of lines; babel's generate sometimes
-                // leaves them hanging around.
-                .replace(/\s+$/gm, '') + '\n';
-    });
+    generated.forEach(
+        ({name, typeName, code, isFragment, extraTypes, experimentalEnums}) => {
+            // We write all generated files to a `__generated__` subdir to keep
+            // things tidy.
+            const targetFileName = options.typeFileName
+                ? options.typeFileName.replace('[operationName]', name)
+                : `${name}.js`;
+            const targetPath = path.join(generatedDir, targetFileName);
+
+            let fileContents =
+                '// @' +
+                `flow\n// AUTOGENERATED -- DO NOT EDIT\n` +
+                `// Generated for operation '${name}' in file '../${path.basename(
+                    fileName,
+                )}'\n` +
+                (options.regenerateCommand
+                    ? `// To regenerate, run '${options.regenerateCommand}'.\n`
+                    : '') +
+                code;
+            if (options.splitTypes && !isFragment) {
+                fileContents +=
+                    `\nexport type ${name} = ${typeName}['response'];\n` +
+                    `export type ${name}Variables = ${typeName}['variables'];\n`;
+            }
+            Object.keys(extraTypes).forEach(
+                (name) =>
+                    (fileContents += `\n\nexport type ${name} = ${extraTypes[name]};`),
+            );
+            const enumNames = Object.keys(experimentalEnums);
+            if (options.experimentalEnums && enumNames.length) {
+                // TODO(somewhatabstract, FEI-4172): Update to fixed eslint-plugin-flowtype
+                // and remove this disable.
+                fileContents += `\n\n/* eslint-disable no-undef */`;
+                enumNames.forEach(
+                    (name) =>
+                        (fileContents += `\nexport ${experimentalEnums[name]};\n`),
+                );
+                fileContents += `/* eslint-enable no-undef */`;
+            }
+
+            addToIndex(targetPath, typeName);
+            files[targetPath] =
+                fileContents
+                    // Remove whitespace from the ends of lines; babel's generate sometimes
+                    // leaves them hanging around.
+                    .replace(/\s+$/gm, '') + '\n';
+        },
+    );
 
     return {files, indexContents};
 };
 
+const getGeneratedDir = (fileName: string, options: GenerateConfig) => {
+    const generatedDirectory = options.generatedDirectory ?? '__generated__';
+    if (path.isAbsolute(generatedDirectory)) {
+        // fileName is absolute here, so we make it relative to cwd
+        // for more reasonable filenames.  We convert leading ..'s
+        // to `__` so this doesn't escape the output directory.
+        return path.join(
+            generatedDirectory,
+            path
+                .relative(process.cwd(), path.dirname(fileName))
+                .replace(/\.\.\//g, '__/'),
+        );
+    } else {
+        return path.join(path.dirname(fileName), generatedDirectory);
+    }
+};
+
 export const generateTypeFiles = (
     fileName: string,
     schema: Schema,
     document: DocumentNode,
-    options: Options,
+    options: GenerateConfig,
 ) => {
-    const generatedDir = path.join(
-        path.dirname(fileName),
-        options.generatedDirectory ?? '__generated__',
-    );
+    const generatedDir = getGeneratedDir(fileName, options);
     const indexFile = path.join(generatedDir, 'index.js');
 
     if (!fs.existsSync(generatedDir)) {
@@ -137,35 +147,33 @@ export const generateTypeFiles = (
 };
 
 export const processPragmas = (
-    options: ExternalOptions,
+    generateConfig: GenerateConfig,
+    crawlConfig: CrawlConfig,
     rawSource: string,
-): null | Options => {
-    if (options.ignorePragma && rawSource.includes(options.ignorePragma)) {
-        return null;
+): {generate: boolean, strict?: boolean} => {
+    if (
+        crawlConfig.ignorePragma &&
+        rawSource.includes(crawlConfig.ignorePragma)
+    ) {
+        return {generate: false};
     }
 
-    const autogen = options.loosePragma
-        ? rawSource.includes(options.loosePragma)
+    const autogen = crawlConfig.loosePragma
+        ? rawSource.includes(crawlConfig.loosePragma)
         : false;
-    const autogenStrict = options.pragma
-        ? rawSource.includes(options.pragma)
+    const autogenStrict = crawlConfig.pragma
+        ? rawSource.includes(crawlConfig.pragma)
         : false;
-    const noPragmas = !options.loosePragma && !options.pragma;
+    const noPragmas = !crawlConfig.loosePragma && !crawlConfig.pragma;
 
     if (autogen || autogenStrict || noPragmas) {
         return {
-            regenerateCommand: options.regenerateCommand,
-            strictNullability: noPragmas
-                ? options.strictNullability
+            generate: true,
+            strict: noPragmas
+                ? generateConfig.strictNullability
                 : autogenStrict || !autogen,
-            readOnlyArray: options.readOnlyArray,
-            scalars: options.scalars,
-            splitTypes: options.splitTypes,
-            generatedDirectory: options.generatedDirectory,
-            exportAllObjectTypes: options.exportAllObjectTypes,
-            typeFileName: options.typeFileName,
         };
     } else {
-        return null;
+        return {generate: false};
     }
 };