@khanacademy/graphql-flow 1.2.0 → 2.0.0

package/src/{generateResponseType.js → generateResponseType.ts}

@@ -1,19 +1,21 @@
-// @flow
 /* eslint-disable no-console */
 import generate from '@babel/generator'; // eslint-disable-line flowtype-errors/uncovered
 import * as babelTypes from '@babel/types';
-import {type BabelNodeFlowType} from '@babel/types';
+import {TSType} from '@babel/types';
 import type {
     FieldNode,
     IntrospectionOutputTypeRef,
     OperationDefinitionNode,
     FragmentDefinitionNode,
+    SelectionNode,
 } from 'graphql';
 import type {Context, Schema, Selections} from './types';
 import {
     liftLeadingPropertyComments,
     maybeAddDescriptionComment,
     transferLeadingComments,
+    nullableType,
+    objectTypeFromProperties,
 } from './utils';
 import {enumTypeToFlow, scalarTypeToFlow} from './enums';
 import type {
@@ -22,16 +24,8 @@ import type {
     IntrospectionObjectType,
     IntrospectionUnionType,
 } from 'graphql/utilities/introspectionQuery';
-import {
-    BabelNodeObjectTypeProperty,
-    BabelNodeObjectTypeSpreadProperty,
-} from '@babel/types';
 
-export const generateResponseType = (
-    schema: Schema,
-    query: OperationDefinitionNode,
-    ctx: Context,
-): string => {
+export const generateResponseType = (schema: Schema, query: OperationDefinitionNode, ctx: Context): string => {
     const ast = querySelectionToObjectType(
         ctx,
         query.selectionSet.selections,
@@ -46,15 +40,13 @@ export const generateResponseType = (
 
 const sortedObjectTypeAnnotation = (
     ctx: Context,
-    properties: Array<
-        BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty,
-    >,
-) => {
-    const obj = babelTypes.objectTypeAnnotation(
+    properties: Array<babelTypes.TSPropertySignature>,
+): babelTypes.TSType => {
+    const obj = objectTypeFromProperties(
         properties.sort((a, b) => {
             if (
-                a.type === 'ObjectTypeProperty' &&
-                b.type === 'ObjectTypeProperty'
+                a.type === 'TSPropertySignature' &&
+                b.type === 'TSPropertySignature'
             ) {
                 const aName = a.key.type === 'Identifier' ? a.key.name : '';
                 const bName = b.key.type === 'Identifier' ? b.key.name : '';
@@ -62,26 +54,18 @@ const sortedObjectTypeAnnotation = (
             }
             return 0;
         }),
-        undefined /* indexers */,
-        undefined /* callProperties */,
-        undefined /* internalSlots */,
-        true /* exact */,
     );
     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));
+        return babelTypes.tsTypeReference(babelTypes.identifier(name));
     } else {
         return obj;
     }
 };
 
-export const generateFragmentType = (
-    schema: Schema,
-    fragment: FragmentDefinitionNode,
-    ctx: Context,
-): string => {
+export const generateFragmentType = (schema: Schema, fragment: FragmentDefinitionNode, ctx: Context): string => {
     const onType = fragment.typeCondition.name.value;
     let ast;
 
@@ -115,20 +99,16 @@ export const generateFragmentType = (
     return generate(ast).code;
 };
 
-const _typeToFlow = (
-    ctx: Context,
-    type,
-    selection,
-): babelTypes.BabelNodeFlowType => {
+const _typeToFlow = (ctx: Context, type: any, selection: FieldNode): babelTypes.TSType => {
     if (type.kind === 'SCALAR') {
         return scalarTypeToFlow(ctx, type.name);
     }
     if (type.kind === 'LIST') {
-        return babelTypes.genericTypeAnnotation(
+        return babelTypes.tsTypeReference(
             ctx.readOnlyArray
-                ? babelTypes.identifier('$ReadOnlyArray')
+                ? babelTypes.identifier('ReadonlyArray')
                 : babelTypes.identifier('Array'),
-            babelTypes.typeParameterInstantiation([
+            babelTypes.tsTypeParameterInstantiation([
                 typeToFlow(ctx, type.ofType, selection),
             ]),
         );
@@ -137,7 +117,7 @@ const _typeToFlow = (
         const union = ctx.schema.unionsByName[type.name];
         if (!selection.selectionSet) {
             console.log('no selection set', selection);
-            return babelTypes.anyTypeAnnotation();
+            return babelTypes.tsAnyKeyword();
         }
         return unionOrInterfaceToFlow(
             ctx,
@@ -149,7 +129,7 @@ const _typeToFlow = (
     if (type.kind === 'INTERFACE') {
         if (!selection.selectionSet) {
             console.log('no selection set', selection);
-            return babelTypes.anyTypeAnnotation();
+            return babelTypes.tsAnyKeyword();
         }
         return unionOrInterfaceToFlow(
             ctx,
@@ -162,18 +142,18 @@ const _typeToFlow = (
     }
     if (type.kind !== 'OBJECT') {
         console.log('not object', type);
-        return babelTypes.anyTypeAnnotation();
+        return babelTypes.tsAnyKeyword();
     }
 
     const tname = type.name;
     if (!ctx.schema.typesByName[tname]) {
         console.log('unknown referenced type', tname);
-        return babelTypes.anyTypeAnnotation();
+        return babelTypes.tsAnyKeyword();
     }
     const childType = ctx.schema.typesByName[tname];
     if (!selection.selectionSet) {
         console.log('no selection set', selection);
-        return babelTypes.anyTypeAnnotation();
+        return babelTypes.tsAnyKeyword();
     }
     return maybeAddDescriptionComment(
         childType.description,
@@ -186,11 +166,7 @@ const _typeToFlow = (
     );
 };
 
-export const typeToFlow = (
-    ctx: Context,
-    type: IntrospectionOutputTypeRef,
-    selection: FieldNode,
-): babelTypes.BabelNodeFlowType => {
+export const typeToFlow = (ctx: Context, type: IntrospectionOutputTypeRef, selection: FieldNode): babelTypes.TSType => {
     // throw new Error('npoe');
     if (type.kind === 'NON_NULL') {
         return _typeToFlow(ctx, type.ofType, selection);
@@ -200,23 +176,25 @@ export const typeToFlow = (
         return _typeToFlow(ctx, type, selection);
     }
     const inner = _typeToFlow(ctx, type, selection);
-    const result = babelTypes.nullableTypeAnnotation(inner);
+    const result = nullableType(inner);
     return transferLeadingComments(inner, result);
 };
 
-const ensureOnlyOneTypenameProperty = (properties) => {
+const ensureOnlyOneTypenameProperty = (properties: Array<babelTypes.TSPropertySignature>) => {
     let seenTypeName: false | string = false;
     return properties.filter((type) => {
         // The apollo-utilities "addTypeName" utility will add it
         // even if it's already specified :( so we have to filter out
         // the extra one here.
         if (
-            type.type === 'ObjectTypeProperty' &&
+            type.type === 'TSPropertySignature' &&
+            type.key.type === "Identifier" &&
             type.key.name === '__typename'
         ) {
             const name =
-                type.value.type === 'StringLiteralTypeAnnotation'
-                    ? type.value.value
+                type.typeAnnotation?.typeAnnotation.type === 'TSLiteralType' && 
+                type.typeAnnotation.typeAnnotation.literal.type === 'StringLiteral'
+                    ? type.typeAnnotation.typeAnnotation.literal.value
                     : 'INVALID';
             if (seenTypeName) {
                 if (name !== seenTypeName) {
@@ -232,12 +210,7 @@ const ensureOnlyOneTypenameProperty = (properties) => {
     });
 };
 
-const querySelectionToObjectType = (
-    ctx: Context,
-    selections,
-    type,
-    typeName: string,
-): BabelNodeFlowType => {
+const querySelectionToObjectType = (ctx: Context, selections: any, type: any, typeName: string): babelTypes.TSType => {
     return sortedObjectTypeAnnotation(
         ctx,
         ensureOnlyOneTypenameProperty(
@@ -249,86 +222,96 @@ const querySelectionToObjectType = (
 export const objectPropertiesToFlow = (
     ctx: Context,
     type: IntrospectionObjectType & {
-        fieldsByName: {[name: string]: IntrospectionField},
+        fieldsByName: {
+            [name: string]: IntrospectionField
+        }
     },
     typeName: string,
     selections: Selections,
-): Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty> => {
-    return [].concat(
-        ...selections.map((selection) => {
-            switch (selection.kind) {
-                case 'InlineFragment': {
-                    const newTypeName =
-                        selection.typeCondition?.name.value ?? typeName;
-                    if (newTypeName !== typeName) {
-                        return [];
-                    }
-                    return objectPropertiesToFlow(
-                        ctx,
-                        ctx.schema.typesByName[newTypeName],
-                        newTypeName,
-                        selection.selectionSet.selections,
-                    );
+): Array<babelTypes.TSPropertySignature> => {
+    return selections.flatMap((selection) => {
+        switch (selection.kind) {
+            case 'InlineFragment': {
+                const newTypeName =
+                    selection.typeCondition?.name.value ?? typeName;
+                if (newTypeName !== typeName) {
+                    return [];
                 }
-                case 'FragmentSpread':
-                    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(
+                return objectPropertiesToFlow(
+                    ctx,
+                    ctx.schema.typesByName[newTypeName],
+                    newTypeName,
+                    selection.selectionSet.selections,
+                );
+            }
+            case 'FragmentSpread':
+                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.tsPropertySignature(
+                            babelTypes.identifier(selection.name.value),
+                            babelTypes.tsTypeAnnotation(
+                                babelTypes.tsTypeReference(
                                     babelTypes.identifier(`UNKNOWN_FRAGMENT`),
-                                ),
+                                )
                             ),
-                        ];
-                    }
+                        ),
+                    ];
+                }
 
-                    return objectPropertiesToFlow(
-                        ctx,
-                        type,
-                        typeName,
-                        ctx.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;
-                    const alias: string = selection.alias
-                        ? selection.alias.value
-                        : name;
-                    if (name === '__typename') {
-                        return [
-                            babelTypes.objectTypeProperty(
-                                babelTypes.identifier(alias),
-                                babelTypes.stringLiteralTypeAnnotation(
-                                    typeName,
+            case 'Field':
+                const name = selection.name.value;
+                const alias: string = selection.alias
+                    ? selection.alias.value
+                    : name;
+                if (name === '__typename') {
+                    return [
+                        babelTypes.tsPropertySignature(
+                            babelTypes.identifier(alias),
+                            babelTypes.tsTypeAnnotation(
+                                babelTypes.tsLiteralType(
+                                    babelTypes.stringLiteral(typeName),
                                 ),
                             ),
-                        ];
-                    }
-                    if (!type.fieldsByName[name]) {
-                        ctx.errors.push(
-                            `Unknown field '${name}' for type '${typeName}'`,
-                        );
-                        return babelTypes.objectTypeProperty(
+                        ),
+                    ];
+                }
+                if (!type.fieldsByName[name]) {
+                    ctx.errors.push(
+                        `Unknown field '${name}' for type '${typeName}'`,
+                    );
+                    return [
+                        babelTypes.tsPropertySignature(
                             babelTypes.identifier(alias),
-                            babelTypes.genericTypeAnnotation(
-                                babelTypes.identifier(
-                                    `UNKNOWN_FIELD["${name}"]`,
-                                ),
+                            babelTypes.tsTypeAnnotation(
+                                babelTypes.tsTypeReference(
+                                    babelTypes.identifier(
+                                        `UNKNOWN_FIELD["${name}"]`,
+                                    ),
+                                )
                             ),
-                        );
-                    }
-                    const typeField = type.fieldsByName[name];
+                        )
+                    ];
+                }
+                const typeField = type.fieldsByName[name];
 
-                    return [
-                        maybeAddDescriptionComment(
-                            typeField.description,
-                            liftLeadingPropertyComments(
-                                babelTypes.objectTypeProperty(
-                                    babelTypes.identifier(alias),
+                return [
+                    maybeAddDescriptionComment(
+                        typeField.description,
+                        liftLeadingPropertyComments(
+                            babelTypes.tsPropertySignature(
+                                babelTypes.identifier(alias),
+                                babelTypes.tsTypeAnnotation(
                                     typeToFlow(
                                         {
                                             ...ctx,
@@ -337,46 +320,44 @@ export const objectPropertiesToFlow = (
                                         typeField.type,
                                         selection,
                                     ),
-                                ),
+                                )
                             ),
                         ),
-                    ];
+                    ),
+                ];
 
-                default:
-                    ctx.errors.push(
-                        // eslint-disable-next-line flowtype-errors/uncovered
-                        `Unsupported selection kind '${selection.kind}'`,
-                    );
-                    return [];
-            }
-        }),
-    );
+            default:
+                ctx.errors.push(
+                    // @ts-expect-error: `selection` is `never` here
+                    `Unsupported selection kind '${selection.kind}'`,
+                );
+                return [];
+        }
+    });
 };
 
 export const unionOrInterfaceToFlow = (
     ctx: Context,
-    type:
-        | IntrospectionUnionType
-        | (IntrospectionInterfaceType & {
-              fieldsByName: {[key: string]: IntrospectionField},
-          }),
+    type: IntrospectionUnionType | IntrospectionInterfaceType & {
+        fieldsByName: {
+            [key: string]: IntrospectionField
+        }
+    },
     selections: Selections,
-): BabelNodeFlowType => {
+): TSType => {
     const allFields = selections.every(
         (selection) => selection.kind === 'Field',
     );
     const selectedAttributes: Array<{
-        attributes: Array<
-            BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty,
-        >,
-        typeName: string,
+        attributes: Array<babelTypes.TSPropertySignature>
+        typeName: string
     }> = type.possibleTypes
         .slice()
         .sort((a, b) => {
             return a.name < b.name ? -1 : 1;
         })
         .map((possible) => {
-            const configWithUpdatedPath = {
+            const configWithUpdatedPath: Context = {
                 ...ctx,
                 path: allFields ? ctx.path : ctx.path.concat([possible.name]),
             };
@@ -401,22 +382,23 @@ export const unionOrInterfaceToFlow = (
         const sharedAttributes = selectedAttributes[0].attributes.slice();
         const typeNameIndex = selectedAttributes[0].attributes.findIndex(
             (x) =>
-                x.type === 'ObjectTypeProperty' &&
+                x.type === 'TSPropertySignature' &&
                 x.key.type === 'Identifier' &&
                 x.key.name === '__typename',
         );
         if (typeNameIndex !== -1) {
-            sharedAttributes[typeNameIndex] = babelTypes.objectTypeProperty(
+            sharedAttributes[typeNameIndex] = babelTypes.tsPropertySignature(
                 babelTypes.identifier('__typename'),
-                babelTypes.unionTypeAnnotation(
-                    selectedAttributes.map(
-                        (attrs) =>
-                            // eslint-disable-next-line flowtype-errors/uncovered
-                            ((attrs.attributes[
-                                typeNameIndex
-                            ]: any): BabelNodeObjectTypeProperty).value,
+                babelTypes.tsTypeAnnotation(
+                    babelTypes.tsUnionType(
+                        selectedAttributes.map(
+                            (attrs) =>
+                                (attrs.attributes[
+                                    typeNameIndex
+                                ] as babelTypes.TSPropertySignature).typeAnnotation!.typeAnnotation,
+                        ),
                     ),
-                ),
+                )
             );
         }
         return sortedObjectTypeAnnotation(ctx, sharedAttributes);
@@ -457,7 +439,7 @@ export const unionOrInterfaceToFlow = (
      * ```
      * instead of e.g. `getHuman_me_Human`.
      */
-    const result = babelTypes.unionTypeAnnotation(
+    const result = babelTypes.tsUnionType(
         selectedAttributes.map(({typeName, attributes}) =>
             sortedObjectTypeAnnotation(
                 {...ctx, path: ctx.path.concat([typeName])},
@@ -468,24 +450,25 @@ export const unionOrInterfaceToFlow = (
     const name = ctx.path.join('_');
     if (ctx.allObjectTypes && ctx.path.length > 1) {
         ctx.allObjectTypes[name] = result;
-        return babelTypes.genericTypeAnnotation(babelTypes.identifier(name));
+        return babelTypes.tsTypeReference(
+            babelTypes.identifier(name),
+        );
     }
     return result;
 };
-const unionOrInterfaceSelection = (
-    config,
-    type,
-    possible,
-    selection,
-): Array<BabelNodeObjectTypeProperty | BabelNodeObjectTypeSpreadProperty> => {
+const unionOrInterfaceSelection = (config: Context, type: any, possible: any, selection: SelectionNode): Array<babelTypes.TSPropertySignature> => {
     if (selection.kind === 'Field' && selection.name.value === '__typename') {
         const alias = selection.alias
             ? selection.alias.value
             : selection.name.value;
         return [
-            babelTypes.objectTypeProperty(
+            babelTypes.tsPropertySignature(
                 babelTypes.identifier(alias),
-                babelTypes.stringLiteralTypeAnnotation(possible.name),
+                babelTypes.tsTypeAnnotation(
+                    babelTypes.tsLiteralType(
+                        babelTypes.stringLiteral(possible.name),
+                    ),
+                ),
             ),
         ];
     }
@@ -503,10 +486,12 @@ const unionOrInterfaceSelection = (
                     possible.name,
             );
             return [
-                babelTypes.objectTypeProperty(
+                babelTypes.tsPropertySignature(
                     babelTypes.identifier(alias),
-                    babelTypes.genericTypeAnnotation(
-                        babelTypes.identifier(`UNKNOWN_FIELD`),
+                    babelTypes.tsTypeAnnotation(
+                        babelTypes.tsTypeReference(
+                            babelTypes.identifier(`UNKNOWN_FIELD`),
+                        ),
                     ),
                 ),
             ];
@@ -514,12 +499,14 @@ const unionOrInterfaceSelection = (
         const typeField = type.fieldsByName[name];
         return [
             liftLeadingPropertyComments(
-                babelTypes.objectTypeProperty(
+                babelTypes.tsPropertySignature(
                     babelTypes.identifier(alias),
-                    typeToFlow(
-                        {...config, path: config.path.concat([name])},
-                        typeField.type,
-                        selection,
+                    babelTypes.tsTypeAnnotation(
+                        typeToFlow(
+                            {...config, path: config.path.concat([name])},
+                            typeField.type,
+                            selection,
+                        ),
                     ),
                 ),
             ),
@@ -538,14 +525,12 @@ const unionOrInterfaceSelection = (
                 ]) ||
             typeName === possible.name
         ) {
-            return [].concat(
-                ...fragment.selectionSet.selections.map((selection) =>
-                    unionOrInterfaceSelection(
-                        config,
-                        config.schema.typesByName[possible.name],
-                        possible,
-                        selection,
-                    ),
+            return fragment.selectionSet.selections.flatMap((selection: SelectionNode) =>
+                unionOrInterfaceSelection(
+                    config,
+                    config.schema.typesByName[possible.name],
+                    possible,
+                    selection,
                 ),
             );
         } else {

package/src/{generateTypeFiles.js → generateTypeFiles.ts}

@@ -1,15 +1,10 @@
-// @flow
 import type {DocumentNode} from 'graphql';
 import type {GenerateConfig, CrawlConfig, Schema} from './types';
 import fs from 'fs';
 import path from 'path';
 import {documentToFlowTypes} from '.';
-// eslint-disable-next-line flowtype-errors/uncovered
-import {convert} from '@khanacademy/flow-to-ts/dist/convert.bundle';
 
-export const indexPrelude = (regenerateCommand?: string): string => `// @flow
-//
-// AUTOGENERATED
+export const indexPrelude = (regenerateCommand?: string): string => `// AUTOGENERATED
 // NOTE: New response types are added to this file automatically.
 //       Outdated response types can be removed manually as they are deprecated.
 //${regenerateCommand ? '      To regenerate, run ' + regenerateCommand : ''}
@@ -24,14 +19,19 @@ export const generateTypeFileContents = (
     options: GenerateConfig,
     generatedDir: string,
     indexContents: string,
-): {indexContents: string, files: {[key: string]: string}} => {
-    const files = {};
+): {
+    indexContents: string
+    files: {
+        [key: string]: string
+    }
+} => {
+    const files: Record<string, any> = {};
 
-    /// Write export for __generated__/index.js if it doesn't exist
-    const addToIndex = (filePath, typeName) => {
+    /// Write export for __generated__/index.ts if it doesn't exist
+    const addToIndex = (filePath: string, typeName: unknown) => {
         if (options.typeScript || options.omitFileExtensions) {
             // Typescript doesn't like file extensions
-            filePath = filePath.replace(/\.js$/, '');
+            filePath = filePath.replace(/\.ts$/, '');
         }
         const newLine = `export type {${typeName}} from './${path.basename(
             filePath,
@@ -50,12 +50,11 @@ export const generateTypeFileContents = (
             // things tidy.
             const targetFileName = options.typeFileName
                 ? options.typeFileName.replace('[operationName]', name)
-                : `${name}.js`;
+                : `${name}.ts`;
             const targetPath = path.join(generatedDir, targetFileName);
 
             let fileContents =
-                '// @' +
-                `flow\n// AUTOGENERATED -- DO NOT EDIT\n` +
+                `// AUTOGENERATED -- DO NOT EDIT\n` +
                 `// Generated for operation '${name}' in file '../${path.basename(
                     fileName,
                 )}'\n` +
@@ -120,10 +119,7 @@ export const generateTypeFiles = (
     options: GenerateConfig,
 ) => {
     const generatedDir = getGeneratedDir(fileName, options);
-    const indexFile = path.join(
-        generatedDir,
-        'index' + (options.typeScript ? '.ts' : '.js'),
-    );
+    const indexFile = path.join(generatedDir, 'index.ts');
 
     if (!fs.existsSync(generatedDir)) {
         fs.mkdirSync(generatedDir, {recursive: true});
@@ -142,17 +138,8 @@ export const generateTypeFiles = (
     );
 
     fs.writeFileSync(indexFile, indexContents);
-    Object.keys(files).forEach((key) => {
-        let fname = key;
-        if (options.typeScript) {
-            // eslint-disable-next-line flowtype-errors/uncovered
-            files[key] = convert(files[key]).replace(
-                `variables: {}`,
-                `variables: Record<never, never>`,
-            );
-            fname = key.replace(/\.js$/, '.ts');
-        }
-        fs.writeFileSync(fname, files[key]);
+    Object.keys(files).forEach((fname) => {
+        fs.writeFileSync(fname, files[fname]);
     });
 
     fs.writeFileSync(indexFile, indexContents);
@@ -162,7 +149,10 @@ export const processPragmas = (
     generateConfig: GenerateConfig,
     crawlConfig: CrawlConfig,
     rawSource: string,
-): {generate: boolean, strict?: boolean} => {
+): {
+    generate: boolean
+    strict?: boolean
+} => {
     if (
         crawlConfig.ignorePragma &&
         rawSource.includes(crawlConfig.ignorePragma)