@khanacademy/graphql-flow 1.2.0 → 2.0.0

package/{dist/cli/__test__/config.test.js → src/cli/__test__/config.test.ts}

@@ -1,14 +1,13 @@
-// @flow
 import type {Config} from '../../types';
 
 import {findApplicableConfig, validateOrThrow} from '../config';
-import configSchema from '../schema.json'; // eslint-disable-line flowtype-errors/uncovered
+import configSchema from '../../../schema.json';
 
 describe('findApplicableConfig', () => {
     it('should work with one that matches', () => {
         const config = {
             schemaFilePath: 'ok.graphql',
-        };
+        } as const;
         expect(findApplicableConfig('/hello', config)).toBe(config);
     });
 
@@ -16,8 +15,8 @@ describe('findApplicableConfig', () => {
         const config = {
             schemaFilePath: 'ok.graphql',
             exclude: [/hello$/],
-        };
-        expect(findApplicableConfig('/hello', config)).toBeUndefined();
+        } as const;
+        expect(findApplicableConfig('/hello', config as any)).toBeUndefined();
     });
 
     it('should match & exclude with multiple configs', () => {
@@ -88,7 +87,7 @@ describe('jsonschema validation', () => {
             generatedDirectory: '__graphql-types__',
             exportAllObjectTypes: true,
             schemaFilePath: './composed_schema.graphql',
-        };
+        } as const;
         const config: Config = {
             crawl: {
                 root: '/here/we/crawl',

package/{dist/cli/config.js.flow → src/cli/config.ts}

@@ -1,9 +1,8 @@
-// @flow
 import type {Schema} from '../types';
 import type {GraphQLSchema} from 'graphql/type/schema';
 
 import {schemaFromIntrospectionData} from '../schemaFromIntrospectionData';
-import configSchema from './schema.json'; // eslint-disable-line flowtype-errors/uncovered
+import configSchema from '../../schema.json'; // eslint-disable-line flowtype-errors/uncovered
 
 import fs from 'fs';
 import {
@@ -11,12 +10,12 @@ import {
     buildSchema,
     getIntrospectionQuery,
     graphqlSync,
-    type IntrospectionQuery,
+    IntrospectionQuery,
 } from 'graphql';
 import type {Config, GenerateConfig} from '../types';
 import {validate} from 'jsonschema'; // eslint-disable-line flowtype-errors/uncovered
 
-export const validateOrThrow = (value: mixed, jsonSchema: mixed) => {
+export const validateOrThrow = (value: unknown, jsonSchema: unknown) => {
     /* eslint-disable flowtype-errors/uncovered */
     const result = validate(value, jsonSchema);
     if (!result.valid) {
@@ -28,7 +27,6 @@ export const validateOrThrow = (value: mixed, jsonSchema: mixed) => {
 };
 
 export const loadConfigFile = (configFile: string): Config => {
-    // $FlowIgnore
     const data: Config = require(configFile); // eslint-disable-line flowtype-errors/uncovered
     validateOrThrow(data, configSchema); // eslint-disable-line flowtype-errors/uncovered
     return data;
@@ -47,7 +45,7 @@ export const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {
         );
         const schemaForTypeGeneration = schemaFromIntrospectionData(
             // eslint-disable-next-line flowtype-errors/uncovered
-            ((queryResponse.data: any): IntrospectionQuery),
+            (queryResponse.data as IntrospectionQuery),
         );
         return [schemaForValidation, schemaForTypeGeneration];
     } else {
@@ -65,15 +63,12 @@ export const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {
  * - no item of `exclude` matches
  * - at least one item of `match` matches
  */
-export const findApplicableConfig = (
-    path: string,
-    configs: Array<GenerateConfig> | GenerateConfig,
-): ?GenerateConfig => {
+export const findApplicableConfig = (path: string, configs: Array<GenerateConfig> | GenerateConfig): GenerateConfig | null | undefined => {
     if (!Array.isArray(configs)) {
         configs = [configs];
     }
     return configs.find((config) => {
-        if (config.exclude?.some((exclude) => new RegExp(exclude).test(path))) {
+        if (config.exclude?.some((exclude: any) => new RegExp(exclude).test(path))) {
             return false;
         }
         if (!config.match) {

package/src/cli/{run.js → run.ts}

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// @flow
 /* eslint-disable no-console */
 import type {Schema} from '../types';
 import type {GraphQLSchema} from 'graphql/type/schema';
@@ -13,7 +12,7 @@ import {addTypenameToDocument} from 'apollo-utilities'; // eslint-disable-line f
 
 import {execSync} from 'child_process';
 import {existsSync, mkdirSync, readFileSync, writeFileSync} from 'fs';
-import {type DocumentNode} from 'graphql';
+import {DocumentNode} from 'graphql';
 import {print} from 'graphql/language/printer';
 import {validate} from 'graphql/validation';
 import path from 'path';
@@ -129,7 +128,9 @@ console.log(Object.keys(resolved).length, 'resolved queries');
 
 /** Step (4) */
 
-const schemaCache: {[key: string]: [GraphQLSchema, Schema]} = {};
+const schemaCache: {
+    [key: string]: [GraphQLSchema, Schema]
+} = {};
 const getCachedSchemas = (schemaFilePath: string) => {
     if (!schemaCache[schemaFilePath]) {
         schemaCache[schemaFilePath] = getSchemas(
@@ -208,7 +209,7 @@ Object.keys(resolved).forEach((filePathAndLine) => {
             generateConfig,
         );
         // eslint-disable-next-line flowtype-errors/uncovered
-    } catch (err) {
+    } catch (err: any) {
         console.error(`Error while generating operation from ${raw.loc.path}`);
         console.error(printed);
         // eslint-disable-next-line flowtype-errors/uncovered

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

@@ -1,9 +1,8 @@
-// @flow
 /**
  * Both input & output types can have enums & scalars.
  */
 import * as babelTypes from '@babel/types';
-import type {BabelNodeFlowType} from '@babel/types';
+import type {TSType} from '@babel/types';
 import type {Context} from './types';
 import {maybeAddDescriptionComment} from './utils';
 import type {IntrospectionEnumType} from 'graphql/utilities/introspectionQuery';
@@ -12,13 +11,14 @@ export const experimentalEnumTypeToFlow = (
     ctx: Context,
     enumConfig: IntrospectionEnumType,
     description: string,
-): BabelNodeFlowType => {
-    const enumDeclaration = babelTypes.enumDeclaration(
+): TSType => {
+    const enumDeclaration = babelTypes.tsEnumDeclaration(
         // pass id into generic type annotation
         babelTypes.identifier(enumConfig.name),
-        babelTypes.enumStringBody(
-            enumConfig.enumValues.map((v) =>
-                babelTypes.enumDefaultedMember(babelTypes.identifier(v.name)),
+        enumConfig.enumValues.map((v) =>
+            babelTypes.tsEnumMember(
+                babelTypes.identifier(v.name),
+                babelTypes.stringLiteral(v.name),
             ),
         ),
     );
@@ -29,14 +29,11 @@ export const experimentalEnumTypeToFlow = (
 
     return maybeAddDescriptionComment(
         description,
-        babelTypes.genericTypeAnnotation(enumDeclaration.id),
+        babelTypes.tsTypeReference(enumDeclaration.id),
     );
 };
 
-export const enumTypeToFlow = (
-    ctx: Context,
-    name: string,
-): BabelNodeFlowType => {
+export const enumTypeToFlow = (ctx: Context, name: string): TSType => {
     const enumConfig = ctx.schema.enumsByName[name];
     let combinedDescription = enumConfig.enumValues
         .map(
@@ -56,15 +53,19 @@ export const enumTypeToFlow = (
         ? experimentalEnumTypeToFlow(ctx, enumConfig, combinedDescription)
         : maybeAddDescriptionComment(
               combinedDescription,
-              babelTypes.unionTypeAnnotation(
+              babelTypes.tsUnionType(
                   enumConfig.enumValues.map((n) =>
-                      babelTypes.stringLiteralTypeAnnotation(n.name),
+                      babelTypes.tsLiteralType(
+                          babelTypes.stringLiteral(n.name),
+                      ),
                   ),
               ),
           );
 };
 
-export const builtinScalars: {[key: string]: string} = {
+export const builtinScalars: {
+    [key: string]: string,
+} = {
     Boolean: 'boolean',
     String: 'string',
     DateTime: 'string',
@@ -74,25 +75,22 @@ export const builtinScalars: {[key: string]: string} = {
     Float: 'number',
 };
 
-export const scalarTypeToFlow = (
-    ctx: Context,
-    name: string,
-): BabelNodeFlowType => {
+export const scalarTypeToFlow = (ctx: Context, name: string): TSType => {
     if (builtinScalars[name]) {
-        return babelTypes.genericTypeAnnotation(
+        return babelTypes.tsTypeReference(
             babelTypes.identifier(builtinScalars[name]),
         );
     }
     const underlyingType = ctx.scalars[name];
     if (underlyingType != null) {
-        return babelTypes.genericTypeAnnotation(
+        return babelTypes.tsTypeReference(
             babelTypes.identifier(underlyingType),
         );
     }
     ctx.errors.push(
         `Unexpected scalar '${name}'! Please add it to the "scalars" argument at the callsite of 'generateFlowTypes()'.`,
     );
-    return babelTypes.genericTypeAnnotation(
+    return babelTypes.tsTypeReference(
         babelTypes.identifier(`UNKNOWN_SCALAR["${name}"]`),
     );
 };