@khanacademy/graphql-flow 1.1.2 → 2.0.0

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,28 +19,27 @@ 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) => {
-        if (options.typeScript) {
+    /// 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,
         )}';`;
-        if (indexContents.indexOf('./' + path.basename(filePath)) === -1) {
+        // We match the entire new line to avoid issues that can arise from
+        // prefix matches.
+        if (indexContents.indexOf(newLine) === -1) {
             indexContents += newLine + '\n';
-        } else {
-            const lines = indexContents.split('\n').map((line) => {
-                if (line.includes('./' + path.basename(filePath))) {
-                    return newLine;
-                }
-                return line;
-            });
-            indexContents = lines.join('\n');
         }
     };
 
@@ -56,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` +
@@ -126,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});
@@ -148,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);
@@ -168,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)

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

@@ -1,13 +1,9 @@
-// @flow
 import generate from '@babel/generator'; // eslint-disable-line flowtype-errors/uncovered
-import type {
-    BabelNodeFlowType,
-    BabelNodeObjectTypeProperty,
-} from '@babel/types';
 import * as babelTypes from '@babel/types';
 import type {OperationDefinitionNode, TypeNode} from 'graphql/language/ast';
 import type {IntrospectionInputTypeRef} from 'graphql/utilities/introspectionQuery';
 import {builtinScalars, enumTypeToFlow, scalarTypeToFlow} from './enums';
+import {nullableType, isnNullableType, objectTypeFromProperties} from './utils';
 import type {Context, Schema} from './types';
 import {
     liftLeadingPropertyComments,
@@ -18,18 +14,18 @@ import {
 export const inputObjectToFlow = (
     ctx: Context,
     name: string,
-): BabelNodeFlowType => {
+): babelTypes.TSType => {
     const inputObject = ctx.schema.inputObjectsByName[name];
     if (!inputObject) {
         ctx.errors.push(`Unknown input object ${name}`);
-        return babelTypes.stringLiteralTypeAnnotation(
-            `Unknown input object ${name}`,
+        return babelTypes.tsLiteralType(
+            babelTypes.stringLiteral(`Unknown input object ${name}`),
         );
     }
 
     return maybeAddDescriptionComment(
         inputObject.description,
-        babelTypes.objectTypeAnnotation(
+        objectTypeFromProperties(
             inputObject.inputFields.map((vbl) =>
                 maybeAddDescriptionComment(
                     vbl.description,
@@ -39,22 +35,21 @@ export const inputObjectToFlow = (
                     ),
                 ),
             ),
-            undefined /* indexers */,
-            undefined /* callProperties */,
-            undefined /* internalSlots */,
-            true /* exact */,
         ),
     );
 };
 
 export const maybeOptionalObjectTypeProperty = (
     name: string,
-    type: babelTypes.BabelNodeFlowType,
-): BabelNodeObjectTypeProperty => {
+    type: babelTypes.TSType,
+): babelTypes.TSPropertySignature => {
     const prop = liftLeadingPropertyComments(
-        babelTypes.objectTypeProperty(babelTypes.identifier(name), type),
+        babelTypes.tsPropertySignature(
+            babelTypes.identifier(name),
+            babelTypes.tsTypeAnnotation(type),
+        ),
     );
-    if (type.type === 'NullableTypeAnnotation') {
+    if (isnNullableType(type)) {
         prop.optional = true;
     }
     return prop;
@@ -63,18 +58,18 @@ export const maybeOptionalObjectTypeProperty = (
 export const inputRefToFlow = (
     ctx: Context,
     inputRef: IntrospectionInputTypeRef,
-): BabelNodeFlowType => {
+): babelTypes.TSType => {
     if (inputRef.kind === 'NON_NULL') {
         return _inputRefToFlow(ctx, inputRef.ofType);
     }
     const result = _inputRefToFlow(ctx, inputRef);
-    return transferLeadingComments(
-        result,
-        babelTypes.nullableTypeAnnotation(result),
-    );
+    return transferLeadingComments(result, nullableType(result));
 };
 
-const _inputRefToFlow = (ctx: Context, inputRef: IntrospectionInputTypeRef) => {
+const _inputRefToFlow = (
+    ctx: Context,
+    inputRef: IntrospectionInputTypeRef,
+): babelTypes.TSType => {
     if (inputRef.kind === 'SCALAR') {
         return scalarTypeToFlow(ctx, inputRef.name);
     }
@@ -85,28 +80,27 @@ const _inputRefToFlow = (ctx: Context, inputRef: IntrospectionInputTypeRef) => {
         return inputObjectToFlow(ctx, inputRef.name);
     }
     if (inputRef.kind === 'LIST') {
-        return babelTypes.genericTypeAnnotation(
-            babelTypes.identifier('$ReadOnlyArray'),
-            babelTypes.typeParameterInstantiation([
+        return babelTypes.tsTypeReference(
+            babelTypes.identifier('ReadonlyArray'),
+            babelTypes.tsTypeParameterInstantiation([
                 inputRefToFlow(ctx, inputRef.ofType),
             ]),
         );
     }
-    return babelTypes.stringLiteralTypeAnnotation(JSON.stringify(inputRef));
+    return babelTypes.tsLiteralType(
+        babelTypes.stringLiteral(JSON.stringify(inputRef)),
+    );
 };
 
-const variableToFlow = (ctx: Context, type: TypeNode) => {
+const variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
     if (type.kind === 'NonNullType') {
         return _variableToFlow(ctx, type.type);
     }
     const result = _variableToFlow(ctx, type);
-    return transferLeadingComments(
-        result,
-        babelTypes.nullableTypeAnnotation(result),
-    );
+    return transferLeadingComments(result, nullableType(result));
 };
 
-const _variableToFlow = (ctx: Context, type: TypeNode) => {
+const _variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
     if (type.kind === 'NamedType') {
         if (builtinScalars[type.name.value]) {
             return scalarTypeToFlow(ctx, type.name.value);
@@ -116,22 +110,22 @@ const _variableToFlow = (ctx: Context, type: TypeNode) => {
         }
         const customScalarType = ctx.scalars[type.name.value];
         if (customScalarType) {
-            return babelTypes.genericTypeAnnotation(
+            return babelTypes.tsTypeReference(
                 babelTypes.identifier(customScalarType),
             );
         }
         return inputObjectToFlow(ctx, type.name.value);
     }
     if (type.kind === 'ListType') {
-        return babelTypes.genericTypeAnnotation(
-            babelTypes.identifier('$ReadOnlyArray'),
-            babelTypes.typeParameterInstantiation([
+        return babelTypes.tsTypeReference(
+            babelTypes.identifier('ReadonlyArray'),
+            babelTypes.tsTypeParameterInstantiation([
                 variableToFlow(ctx, type.type),
             ]),
         );
     }
-    return babelTypes.stringLiteralTypeAnnotation(
-        'UNKNOWN' + JSON.stringify(type),
+    return babelTypes.tsLiteralType(
+        babelTypes.stringLiteral('UNKNOWN' + JSON.stringify(type)),
     );
 };
 
@@ -140,17 +134,13 @@ export const generateVariablesType = (
     item: OperationDefinitionNode,
     ctx: Context,
 ): string => {
-    const variableObject = babelTypes.objectTypeAnnotation(
+    const variableObject = objectTypeFromProperties(
         (item.variableDefinitions || []).map((vbl) => {
             return maybeOptionalObjectTypeProperty(
                 vbl.variable.name.value,
                 variableToFlow(ctx, vbl.type),
             );
         }),
-        undefined /* indexers */,
-        undefined /* callProperties */,
-        undefined /* internalSlots */,
-        true /* exact */,
     );
     return generate(variableObject).code; // eslint-disable-line flowtype-errors/uncovered
 };

package/{dist/index.js.flow → src/index.ts}

@@ -1,6 +1,6 @@
+import {isTruthy} from '@khanacademy/wonder-stuff-core';
 /* eslint-disable no-console */
 /* flow-uncovered-file */
-// @flow
 /**
  * This tool generates flowtype definitions from graphql queries.
  *
@@ -15,13 +15,13 @@ import {
     generateResponseType,
 } from './generateResponseType';
 import {generateVariablesType} from './generateVariablesType';
-import type {BabelNode} from '@babel/types';
+import type {Node} from '@babel/types';
 
 import type {Context, Schema, GenerateConfig} from './types';
 
 const optionsToConfig = (
     schema: Schema,
-    definitions: $ReadOnlyArray<DefinitionNode>,
+    definitions: ReadonlyArray<DefinitionNode>,
     options?: GenerateConfig,
     errors: Array<string> = [],
 ): Context => {
@@ -30,8 +30,9 @@ const optionsToConfig = (
         readOnlyArray: options?.readOnlyArray ?? true,
         scalars: options?.scalars ?? {},
         typeScript: options?.typeScript ?? false,
-    };
-    const fragments = {};
+        omitFileExtensions: options?.omitFileExtensions ?? false,
+    } as const;
+    const fragments: Record<string, any> = {};
     definitions.forEach((def) => {
         if (def.kind === 'FragmentDefinition') {
             fragments[def.name.value] = def;
@@ -45,8 +46,10 @@ const optionsToConfig = (
         path: [],
         experimentalEnumsMap: options?.experimentalEnums ? {} : undefined,
         ...internalOptions,
-    };
+    } as const;
 
+    // @ts-expect-error: TS2322 - The type 'readonly []' is 'readonly' and cannot be
+    // assigned to the mutable type 'string[]'.
     return config;
 };
 
@@ -58,17 +61,17 @@ export class FlowGenerationError extends Error {
     }
 }
 
-export const documentToFlowTypes = (
-    document: DocumentNode,
-    schema: Schema,
-    options?: GenerateConfig,
-): $ReadOnlyArray<{
-    name: string,
-    typeName: string,
-    code: string,
-    isFragment?: boolean,
-    extraTypes: {[key: string]: string},
-    experimentalEnums: {[key: string]: string},
+export const documentToFlowTypes = (document: DocumentNode, schema: Schema, options?: GenerateConfig): ReadonlyArray<{
+    name: string
+    typeName: string
+    code: string
+    isFragment?: boolean
+    extraTypes: {
+        [key: string]: string
+    }
+    experimentalEnums: {
+        [key: string]: string
+    }
 }> => {
     const errors: Array<string> = [];
     const config = optionsToConfig(
@@ -81,7 +84,7 @@ export const documentToFlowTypes = (
         .map((item) => {
             if (item.kind === 'FragmentDefinition') {
                 const name = item.name.value;
-                const types = {};
+                const types: Record<string, any> = {};
                 const code = `export type ${name} = ${generateFragmentType(
                     schema,
                     item,
@@ -113,7 +116,7 @@ export const documentToFlowTypes = (
                 (item.operation === 'query' || item.operation === 'mutation') &&
                 item.name
             ) {
-                const types = {};
+                const types: Record<string, any> = {};
                 const name = item.name.value;
                 const response = generateResponseType(schema, item, {
                     ...config,
@@ -130,7 +133,7 @@ export const documentToFlowTypes = (
                 const typeName = `${name}Type`;
                 // TODO(jared): Maybe make this template configurable?
                 // We'll see what's required to get webapp on board.
-                const code = `export type ${typeName} = {|\n    variables: ${variables},\n    response: ${response}\n|};`;
+                const code = `export type ${typeName} = {\n    variables: ${variables},\n    response: ${response}\n};`;
 
                 const extraTypes = codegenExtraTypes(types);
                 const experimentalEnums = codegenExtraTypes(
@@ -140,17 +143,23 @@ export const documentToFlowTypes = (
                 return {name, typeName, code, extraTypes, experimentalEnums};
             }
         })
-        .filter(Boolean);
+        .filter(isTruthy);
     if (errors.length) {
         throw new FlowGenerationError(errors);
     }
     return result;
 };
 
-function codegenExtraTypes(types: {[key: string]: BabelNode}): {
-    [key: string]: string,
+function codegenExtraTypes(
+    types: {
+        [key: string]: Node
+    },
+): {
+    [key: string]: string
 } {
-    const extraTypes: {[key: string]: string} = {};
+    const extraTypes: {
+        [key: string]: string
+    } = {};
     Object.keys(types).forEach((k: string) => {
         // eslint-disable-next-line flowtype-errors/uncovered
         extraTypes[k] = generate(types[k]).code;

package/{dist/parser/__test__/parse.test.js → src/parser/__test__/parse.test.ts}

@@ -1,12 +1,13 @@
-// @flow
-
 import {processFiles} from '../parse';
 import {resolveDocuments} from '../resolve';
 
 import {print} from 'graphql/language/printer';
 
 const fixtureFiles: {
-    [key: string]: string | {text: string, resolvedPath: string},
+    [key: string]: string | {
+        text: string
+        resolvedPath: string
+    }
 } = {
     '/firstFile.js': `
         // Note that you can import graphql-tag as
@@ -151,14 +152,14 @@ const getFileSource = (name: string) => {
 describe('processing fragments in various ways', () => {
     it('should work', () => {
         const files = processFiles(['/thirdFile.js'], getFileSource);
-        Object.keys(files).forEach((k) => {
+        Object.keys(files).forEach((k: any) => {
             expect(files[k].errors).toEqual([]);
         });
         const {resolved, errors} = resolveDocuments(files);
         expect(errors).toEqual([]);
-        const printed = {};
+        const printed: Record<string, any> = {};
         Object.keys(resolved).map(
-            (k) => (printed[k] = print(resolved[k].document).trim()),
+            (k: any) => (printed[k] = print(resolved[k].document).trim()),
         );
         expect(printed).toMatchInlineSnapshot(`
             Object {
@@ -216,7 +217,7 @@ describe('processing fragments in various ways', () => {
 
     it('should flag things it doesnt support', () => {
         const files = processFiles(['/invalidThings.js'], getFileSource);
-        expect(files['/invalidThings.js'].errors.map((m) => m.message))
+        expect(files['/invalidThings.js'].errors.map((m: any) => m.message))
             .toMatchInlineSnapshot(`
             Array [
               "Unable to resolve someExternalFragment",
@@ -228,11 +229,11 @@ describe('processing fragments in various ways', () => {
 
     it('should flag resolution errors', () => {
         const files = processFiles(['/invalidReferences.js'], getFileSource);
-        Object.keys(files).forEach((k) => {
+        Object.keys(files).forEach((k: any) => {
             expect(files[k].errors).toEqual([]);
         });
         const {resolved, errors} = resolveDocuments(files);
-        expect(errors.map((m) => m.message)).toMatchInlineSnapshot(`
+        expect(errors.map((m: any) => m.message)).toMatchInlineSnapshot(`
             Array [
               "Circular import /circular.js -> /invalidReferences.js -> /circular.js",
               "/circular.js has no valid gql export doesntExist",
@@ -240,9 +241,9 @@ describe('processing fragments in various ways', () => {
               "Recursive template dependency! /circular.js:5 ~ 1,2 -> /invalidReferences.js:15 ~ 1,2 -> /circular.js:5",
             ]
         `);
-        const printed = {};
+        const printed: Record<string, any> = {};
         Object.keys(resolved).map(
-            (k) => (printed[k] = print(resolved[k].document).trim()),
+            (k: any) => (printed[k] = print(resolved[k].document).trim()),
         );
         expect(printed).toMatchInlineSnapshot(`Object {}`);
     });