@khanacademy/graphql-flow 1.2.0 → 3.0.0

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 => {
@@ -31,8 +31,8 @@ const optionsToConfig = (
         scalars: options?.scalars ?? {},
         typeScript: options?.typeScript ?? false,
         omitFileExtensions: options?.omitFileExtensions ?? false,
-    };
-    const fragments = {};
+    } as const;
+    const fragments: Record<string, any> = {};
     definitions.forEach((def) => {
         if (def.kind === 'FragmentDefinition') {
             fragments[def.name.value] = def;
@@ -46,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;
 };
 
@@ -59,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(
@@ -82,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,
@@ -114,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,
@@ -131,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(
@@ -141,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 {}`);
     });

package/src/parser/{parse.js → parse.ts}

@@ -1,4 +1,4 @@
-// @flow
+import {isTruthy} from '@khanacademy/wonder-stuff-core';
 import type {
     BabelNodeImportDeclaration,
     BabelNodeVariableDeclarator,
@@ -42,40 +42,54 @@ import {getPathWithExtension} from './utils';
  *   in `gqlOp<Type>()` or not (to inform an auto-wrapper of the future)
  */
 
-export type Template = {|
-    literals: Array<string>,
-    expressions: Array<Document | Import>,
-    loc: Loc,
-|};
-export type Loc = {start: number, end: number, path: string, line: number};
+export type Template = {
+    literals: Array<string>
+    expressions: Array<Document | Import>
+    loc: Loc
+};
+export type Loc = {
+    start: number
+    end: number
+    path: string
+    line: number
+};
 
-export type Document = {|
-    type: 'document',
-    source: Template,
-|};
-export type Import = {|
-    type: 'import',
-    name: string,
-    path: string,
-    loc: Loc,
-|};
+export type Document = {
+    type: 'document'
+    source: Template
+};
+export type Import = {
+    type: 'import'
+    name: string
+    path: string
+    loc: Loc
+};
 
-export type Operation = {|
-    source: Template,
+export type Operation = {
+    source: Template
     // TODO: Determine if an operation is already wrapped
     // in `gqlOp` so we can automatically wrap if needed.
     // needsWrapping: boolean,
-|};
+};
 
-export type FileResult = {|
-    path: string,
-    operations: Array<Operation>,
-    exports: {[key: string]: Document | Import},
-    locals: {[key: string]: Document | Import},
-    errors: Array<{loc: Loc, message: string}>,
-|};
+export type FileResult = {
+    path: string
+    operations: Array<Operation>
+    exports: {
+        [key: string]: Document | Import
+    }
+    locals: {
+        [key: string]: Document | Import
+    }
+    errors: Array<{
+        loc: Loc
+        message: string
+    }>
+};
 
-export type Files = {[path: string]: FileResult};
+export type Files = {
+    [path: string]: FileResult
+};
 
 /**
  * Finds all referenced imports that might possibly be relevant
@@ -86,7 +100,7 @@ export type Files = {[path: string]: FileResult};
  * from a graphql template are treated as relevant.
  */
 const listExternalReferences = (file: FileResult): Array<string> => {
-    const paths = {};
+    const paths: Record<string, any> = {};
     const add = (v: Document | Import, followImports: boolean) => {
         if (v.type === 'import') {
             if (followImports) {
@@ -126,7 +140,10 @@ const listExternalReferences = (file: FileResult): Array<string> => {
 
 export const processFile = (
     filePath: string,
-    contents: string | {text: string, resolvedPath: string},
+    contents: string | {
+        text: string
+        resolvedPath: string
+    },
 ): FileResult => {
     const dir = path.dirname(filePath);
     const result: FileResult = {
@@ -140,7 +157,7 @@ export const processFile = (
         typeof contents === 'string' ? filePath : contents.resolvedPath;
     const text = typeof contents === 'string' ? contents : contents.text;
     const plugins = resolved.match(/\.tsx?$/)
-        ? ['typescript', filePath.endsWith('x') ? 'jsx' : null].filter(Boolean)
+        ? ['typescript', filePath.endsWith('x') ? 'jsx' : null].filter(isTruthy)
         : [['flow', {enums: true}], 'jsx'];
     /* eslint-disable flowtype-errors/uncovered */
     const ast: BabelNodeFile = parse(text, {
@@ -150,7 +167,9 @@ export const processFile = (
     });
     /* eslint-enable flowtype-errors/uncovered */
     const gqlTagNames = [];
-    const seenTemplates: {[key: number]: Document | false} = {};
+    const seenTemplates: {
+        [key: number]: Document | false
+    } = {};
 
     ast.program.body.forEach((toplevel) => {
         if (toplevel.type === 'ImportDeclaration') {
@@ -176,7 +195,7 @@ export const processFile = (
                 const importPath = source.value.startsWith('.')
                     ? path.resolve(path.join(dir, source.value))
                     : source.value;
-                toplevel.specifiers?.forEach((spec) => {
+                toplevel.specifiers?.forEach((spec: unknown) => {
                     if (
                         spec.type === 'ExportSpecifier' &&
                         spec.exported.type === 'Identifier'
@@ -195,7 +214,7 @@ export const processFile = (
                     }
                 });
             } else {
-                toplevel.specifiers?.forEach((spec) => {
+                toplevel.specifiers?.forEach((spec: unknown) => {
                     if (spec.type === 'ExportSpecifier') {
                         const local = result.locals[spec.local.name];
                         if (local && spec.exported.type === 'Identifier') {
@@ -285,7 +304,7 @@ export const processFile = (
 
     /* eslint-disable flowtype-errors/uncovered */
     traverse(ast, {
-        TaggedTemplateExpression(path) {
+        TaggedTemplateExpression(path: unknown) {
             visitTpl(path.node, (name) => {
                 const binding = path.scope.getBinding(name);
                 const start = binding.path.node.init
@@ -306,10 +325,10 @@ export const processFile = (
 const processTemplate = (
     tpl: BabelNodeTaggedTemplateExpression,
     result: FileResult,
-    getTemplate?: (name: string) => Document | null,
     // getBinding?: (name: string) => Binding,
     // seenTemplates,
-): ?Template => {
+    getTemplate?: (name: string) => Document | null,
+): Template | null | undefined => {
     // 'cooked' is the string as runtime javascript will see it.
     const literals = tpl.quasi.quasis.map((q) => q.value.cooked || '');
     const expressions = tpl.quasi.expressions.map(
@@ -347,7 +366,7 @@ const processTemplate = (
     }
     return {
         literals,
-        expressions: expressions.filter(Boolean),
+        expressions: expressions.filter(isTruthy),
         loc: {
             line: tpl.loc?.start.line ?? -1,
             start: tpl.start ?? -1,
@@ -357,18 +376,16 @@ const processTemplate = (
     };
 };
 
-const getLocals = (
-    dir,
-    toplevel: BabelNodeImportDeclaration,
-    myPath: string,
-): ?{[key: string]: Import} => {
+const getLocals = (dir: unknown, toplevel: BabelNodeImportDeclaration, myPath: string): {
+    [key: string]: Import
+} | null | undefined => {
     if (toplevel.importKind === 'type') {
         return null;
     }
     const importPath = toplevel.source.value.startsWith('.')
         ? path.resolve(path.join(dir, toplevel.source.value))
         : toplevel.source.value;
-    const locals = {};
+    const locals: Record<string, any> = {};
     toplevel.specifiers.forEach((spec) => {
         if (spec.type === 'ImportDefaultSpecifier') {
             locals[spec.local.name] = {
@@ -394,9 +411,10 @@ const getLocals = (
 
 export const processFiles = (
     filePaths: Array<string>,
-    getFileSource: (
-        path: string,
-    ) => string | {text: string, resolvedPath: string},
+    getFileSource: (path: string) => string | {
+        text: string
+        resolvedPath: string
+    },
 ): Files => {
     const files: Files = {};
     const toProcess = filePaths.slice();

package/{dist/parser/resolve.js.flow → src/parser/resolve.ts}

@@ -1,4 +1,3 @@
-// @flow
 import gql from 'graphql-tag';
 import {getPathWithExtension} from './utils';
 import type {DocumentNode} from 'graphql/language/ast';
@@ -6,14 +5,15 @@ import type {FileResult, Files, Import, Template, Document} from './parse';
 
 export type Resolved = {
     [key: string]: {
-        document: DocumentNode,
-        raw: Template,
-    },
+        document: DocumentNode
+        raw: Template
+    }
 };
 
-export const resolveDocuments = (
-    files: Files,
-): {resolved: Resolved, errors: FileResult['errors']} => {
+export const resolveDocuments = (files: Files): {
+    resolved: Resolved
+    errors: FileResult['errors']
+} => {
     const resolved: Resolved = {};
     const errors: FileResult['errors'] = [];
     Object.keys(files).forEach((path) => {
@@ -35,8 +35,10 @@ const resolveImport = (
     expr: Import,
     files: Files,
     errors: FileResult['errors'],
-    seen: {[key: string]: true},
-): ?Document => {
+    seen: {
+        [key: string]: true
+    },
+): Document | null | undefined => {
     const absPath: string = getPathWithExtension(expr.path);
     if (seen[absPath]) {
         errors.push({
@@ -72,8 +74,10 @@ const resolveGqlTemplate = (
     files: Files,
     errors: FileResult['errors'],
     resolved: Resolved,
-    seen: {[key: string]: Template},
-): ?DocumentNode => {
+    seen: {
+        [key: string]: Template
+    },
+): DocumentNode | null | undefined => {
     const key = template.loc.path + ':' + template.loc.line;
     if (seen[key]) {
         errors.push({

package/{dist/parser/utils.js.flow → src/parser/utils.ts}

@@ -1,4 +1,3 @@
-// @flow
 import fs from 'fs';
 
 export const getPathWithExtension = (pathWithoutExtension: string): string => {

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

@@ -1,4 +1,3 @@
-// @flow
 /**
  * Takes the introspectionQuery response and parses it into the "Schema"
  * type that we use to look up types, interfaces, etc.
@@ -6,9 +5,7 @@
 import type {IntrospectionQuery} from 'graphql';
 import type {Schema} from './types';
 
-export const schemaFromIntrospectionData = (
-    schema: IntrospectionQuery,
-): Schema => {
+export const schemaFromIntrospectionData = (schema: IntrospectionQuery): Schema => {
     const result: Schema = {
         interfacesByName: {},
         typesByName: {},