@khanacademy/graphql-flow 3.0.0 → 3.1.0

package/src/generateVariablesType.ts

@@ -1,15 +1,15 @@
-import generate from '@babel/generator'; // eslint-disable-line flowtype-errors/uncovered
-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 generate from "@babel/generator";
+import * as babelTypes from "@babel/types";
+import type {OperationDefinitionNode, TypeNode} from "graphql/language/ast";
+import type {IntrospectionInputTypeRef} from "graphql";
+import {builtinScalars, enumTypeToFlow, scalarTypeToFlow} from "./enums";
+import {nullableType, isnNullableType, objectTypeFromProperties} from "./utils";
+import type {Context, Schema} from "./types";
 import {
     liftLeadingPropertyComments,
     maybeAddDescriptionComment,
     transferLeadingComments,
-} from './utils';
+} from "./utils";
 
 export const inputObjectToFlow = (
     ctx: Context,
@@ -59,7 +59,7 @@ export const inputRefToFlow = (
     ctx: Context,
     inputRef: IntrospectionInputTypeRef,
 ): babelTypes.TSType => {
-    if (inputRef.kind === 'NON_NULL') {
+    if (inputRef.kind === "NON_NULL") {
         return _inputRefToFlow(ctx, inputRef.ofType);
     }
     const result = _inputRefToFlow(ctx, inputRef);
@@ -70,18 +70,18 @@ const _inputRefToFlow = (
     ctx: Context,
     inputRef: IntrospectionInputTypeRef,
 ): babelTypes.TSType => {
-    if (inputRef.kind === 'SCALAR') {
+    if (inputRef.kind === "SCALAR") {
         return scalarTypeToFlow(ctx, inputRef.name);
     }
-    if (inputRef.kind === 'ENUM') {
+    if (inputRef.kind === "ENUM") {
         return enumTypeToFlow(ctx, inputRef.name);
     }
-    if (inputRef.kind === 'INPUT_OBJECT') {
+    if (inputRef.kind === "INPUT_OBJECT") {
         return inputObjectToFlow(ctx, inputRef.name);
     }
-    if (inputRef.kind === 'LIST') {
+    if (inputRef.kind === "LIST") {
         return babelTypes.tsTypeReference(
-            babelTypes.identifier('ReadonlyArray'),
+            babelTypes.identifier("ReadonlyArray"),
             babelTypes.tsTypeParameterInstantiation([
                 inputRefToFlow(ctx, inputRef.ofType),
             ]),
@@ -93,7 +93,7 @@ const _inputRefToFlow = (
 };
 
 const variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
-    if (type.kind === 'NonNullType') {
+    if (type.kind === "NonNullType") {
         return _variableToFlow(ctx, type.type);
     }
     const result = _variableToFlow(ctx, type);
@@ -101,7 +101,7 @@ const variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
 };
 
 const _variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
-    if (type.kind === 'NamedType') {
+    if (type.kind === "NamedType") {
         if (builtinScalars[type.name.value]) {
             return scalarTypeToFlow(ctx, type.name.value);
         }
@@ -116,16 +116,16 @@ const _variableToFlow = (ctx: Context, type: TypeNode): babelTypes.TSType => {
         }
         return inputObjectToFlow(ctx, type.name.value);
     }
-    if (type.kind === 'ListType') {
+    if (type.kind === "ListType") {
         return babelTypes.tsTypeReference(
-            babelTypes.identifier('ReadonlyArray'),
+            babelTypes.identifier("ReadonlyArray"),
             babelTypes.tsTypeParameterInstantiation([
                 variableToFlow(ctx, type.type),
             ]),
         );
     }
     return babelTypes.tsLiteralType(
-        babelTypes.stringLiteral('UNKNOWN' + JSON.stringify(type)),
+        babelTypes.stringLiteral("UNKNOWN" + JSON.stringify(type)),
     );
 };
 
@@ -142,5 +142,5 @@ export const generateVariablesType = (
             );
         }),
     );
-    return generate(variableObject).code; // eslint-disable-line flowtype-errors/uncovered
+    return generate(variableObject).code;
 };

package/src/index.ts

@@ -1,4 +1,4 @@
-import {isTruthy} from '@khanacademy/wonder-stuff-core';
+import {isTruthy} from "@khanacademy/wonder-stuff-core";
 /* eslint-disable no-console */
 /* flow-uncovered-file */
 /**
@@ -7,17 +7,17 @@ import {isTruthy} from '@khanacademy/wonder-stuff-core';
  * It relies on `introspection-query.json` existing in this directory,
  * which is produced by running `./tools/graphql-flow/sendIntrospection.js`.
  */
-import type {DefinitionNode, DocumentNode} from 'graphql';
+import type {DefinitionNode, DocumentNode} from "graphql";
 
-import generate from '@babel/generator'; // eslint-disable-line flowtype-errors/uncovered
+import generate from "@babel/generator";
 import {
     generateFragmentType,
     generateResponseType,
-} from './generateResponseType';
-import {generateVariablesType} from './generateVariablesType';
-import type {Node} from '@babel/types';
+} from "./generateResponseType";
+import {generateVariablesType} from "./generateVariablesType";
+import type {Node} from "@babel/types";
 
-import type {Context, Schema, GenerateConfig} from './types';
+import type {Context, Schema, GenerateConfig} from "./types";
 
 const optionsToConfig = (
     schema: Schema,
@@ -34,7 +34,7 @@ const optionsToConfig = (
     } as const;
     const fragments: Record<string, any> = {};
     definitions.forEach((def) => {
-        if (def.kind === 'FragmentDefinition') {
+        if (def.kind === "FragmentDefinition") {
             fragments[def.name.value] = def;
         }
     });
@@ -56,22 +56,26 @@ const optionsToConfig = (
 export class FlowGenerationError extends Error {
     messages: Array<string>;
     constructor(errors: Array<string>) {
-        super(`Graphql-flow type generation failed! ${errors.join('; ')}`);
+        super(`Graphql-flow type generation failed! ${errors.join("; ")}`);
         this.messages = errors;
     }
 }
 
-export const documentToFlowTypes = (document: DocumentNode, schema: Schema, options?: GenerateConfig): ReadonlyArray<{
-    name: string
-    typeName: string
-    code: string
-    isFragment?: boolean
+export const documentToFlowTypes = (
+    document: DocumentNode,
+    schema: Schema,
+    options?: GenerateConfig,
+): ReadonlyArray<{
+    name: string;
+    typeName: string;
+    code: string;
+    isFragment?: boolean;
     extraTypes: {
-        [key: string]: string
-    }
+        [key: string]: string;
+    };
     experimentalEnums: {
-        [key: string]: string
-    }
+        [key: string]: string;
+    };
 }> => {
     const errors: Array<string> = [];
     const config = optionsToConfig(
@@ -82,7 +86,7 @@ export const documentToFlowTypes = (document: DocumentNode, schema: Schema, opti
     );
     const result = document.definitions
         .map((item) => {
-            if (item.kind === 'FragmentDefinition') {
+            if (item.kind === "FragmentDefinition") {
                 const name = item.name.value;
                 const types: Record<string, any> = {};
                 const code = `export type ${name} = ${generateFragmentType(
@@ -112,8 +116,8 @@ export const documentToFlowTypes = (document: DocumentNode, schema: Schema, opti
                 };
             }
             if (
-                item.kind === 'OperationDefinition' &&
-                (item.operation === 'query' || item.operation === 'mutation') &&
+                item.kind === "OperationDefinition" &&
+                (item.operation === "query" || item.operation === "mutation") &&
                 item.name
             ) {
                 const types: Record<string, any> = {};
@@ -150,18 +154,13 @@ export const documentToFlowTypes = (document: DocumentNode, schema: Schema, opti
     return result;
 };
 
-function codegenExtraTypes(
-    types: {
-        [key: string]: Node
-    },
-): {
-    [key: string]: string
+function codegenExtraTypes(types: {[key: string]: Node}): {
+    [key: string]: string;
 } {
     const extraTypes: {
-        [key: string]: string
+        [key: string]: string;
     } = {};
     Object.keys(types).forEach((k: string) => {
-        // eslint-disable-next-line flowtype-errors/uncovered
         extraTypes[k] = generate(types[k]).code;
     });
     return extraTypes;

package/src/parser/__test__/parse.test.ts

@@ -1,15 +1,20 @@
-import {processFiles} from '../parse';
-import {resolveDocuments} from '../resolve';
+import {describe, it, expect} from "@jest/globals";
 
-import {print} from 'graphql/language/printer';
+import {Config} from "../../types";
+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': `
+    "/firstFile.js": `
         // Note that you can import graphql-tag as
         // something other than gql.
         import tagme from 'graphql-tag';
@@ -35,7 +40,7 @@ const fixtureFiles: {
         }
         \`;`,
 
-    '/secondFile.js': `
+    "/secondFile.js": `
         import gql from 'graphql-tag';
         import {fromFirstFile} from './firstFile.js';
         // This import won't be followed, because it's not exported
@@ -52,7 +57,7 @@ const fixtureFiles: {
         \`;
         export {secondFragment};`,
 
-    '/thirdFile.js': `
+    "/thirdFile.js": `
         import {fromFirstFile, alsoFirst, secondFragment} from './secondFile.js';
         import gql from 'graphql-tag';
         import type {someType} from './somePlace';
@@ -91,7 +96,7 @@ const fixtureFiles: {
             \`;
         }`,
 
-    '/invalidThings.js': `
+    "/invalidThings.js": `
         import gql from 'graphql-tag';
         // Importing a fragment from an npm module is invalid.
         import someExternalFragment from 'somewhere';
@@ -107,7 +112,7 @@ const fixtureFiles: {
         \`;
     `,
 
-    '/circular.js': `
+    "/circular.js": `
         import gql from 'graphql-tag';
         export {otherThing} from './invalidReferences.js';
         import {one} from './invalidReferences.js';
@@ -119,7 +124,7 @@ const fixtureFiles: {
         \`;
     `,
 
-    '/invalidReferences.js': `
+    "/invalidReferences.js": `
         import gql from 'graphql-tag';
         import {otherThing, two, doesntExist} from './circular.js';
         // 'otherThing' is imported circularly
@@ -149,13 +154,39 @@ const getFileSource = (name: string) => {
     return fixtureFiles[name];
 };
 
-describe('processing fragments in various ways', () => {
-    it('should work', () => {
-        const files = processFiles(['/thirdFile.js'], getFileSource);
+describe("processing fragments in various ways", () => {
+    it("should work", () => {
+        const config: Config = {
+            crawl: {
+                root: "/here/we/crawl",
+            },
+            generate: {
+                match: [/\.fixture\.js$/],
+                exclude: [
+                    "_test\\.js$",
+                    "\\bcourse-editor-package\\b",
+                    "\\.fixture\\.js$",
+                    "\\b__flowtests__\\b",
+                    "\\bcourse-editor\\b",
+                ],
+                readOnlyArray: false,
+                regenerateCommand: "make gqlflow",
+                scalars: {
+                    JSONString: "string",
+                    KALocale: "string",
+                    NaiveDateTime: "string",
+                },
+                splitTypes: true,
+                generatedDirectory: "__graphql-types__",
+                exportAllObjectTypes: true,
+                schemaFilePath: "./composed_schema.graphql",
+            },
+        };
+        const files = processFiles(["/thirdFile.js"], config, getFileSource);
         Object.keys(files).forEach((k: any) => {
             expect(files[k].errors).toEqual([]);
         });
-        const {resolved, errors} = resolveDocuments(files);
+        const {resolved, errors} = resolveDocuments(files, config);
         expect(errors).toEqual([]);
         const printed: Record<string, any> = {};
         Object.keys(resolved).map(
@@ -215,9 +246,39 @@ 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: any) => m.message))
+    it("should flag things it doesnt support", () => {
+        const config: Config = {
+            crawl: {
+                root: "/here/we/crawl",
+            },
+            generate: {
+                match: [/\.fixture\.js$/],
+                exclude: [
+                    "_test\\.js$",
+                    "\\bcourse-editor-package\\b",
+                    "\\.fixture\\.js$",
+                    "\\b__flowtests__\\b",
+                    "\\bcourse-editor\\b",
+                ],
+                readOnlyArray: false,
+                regenerateCommand: "make gqlflow",
+                scalars: {
+                    JSONString: "string",
+                    KALocale: "string",
+                    NaiveDateTime: "string",
+                },
+                splitTypes: true,
+                generatedDirectory: "__graphql-types__",
+                exportAllObjectTypes: true,
+                schemaFilePath: "./composed_schema.graphql",
+            },
+        };
+        const files = processFiles(
+            ["/invalidThings.js"],
+            config,
+            getFileSource,
+        );
+        expect(files["/invalidThings.js"].errors.map((m: any) => m.message))
             .toMatchInlineSnapshot(`
             Array [
               "Unable to resolve someExternalFragment",
@@ -227,12 +288,42 @@ describe('processing fragments in various ways', () => {
         `);
     });
 
-    it('should flag resolution errors', () => {
-        const files = processFiles(['/invalidReferences.js'], getFileSource);
+    it("should flag resolution errors", () => {
+        const config: Config = {
+            crawl: {
+                root: "/here/we/crawl",
+            },
+            generate: {
+                match: [/\.fixture\.js$/],
+                exclude: [
+                    "_test\\.js$",
+                    "\\bcourse-editor-package\\b",
+                    "\\.fixture\\.js$",
+                    "\\b__flowtests__\\b",
+                    "\\bcourse-editor\\b",
+                ],
+                readOnlyArray: false,
+                regenerateCommand: "make gqlflow",
+                scalars: {
+                    JSONString: "string",
+                    KALocale: "string",
+                    NaiveDateTime: "string",
+                },
+                splitTypes: true,
+                generatedDirectory: "__graphql-types__",
+                exportAllObjectTypes: true,
+                schemaFilePath: "./composed_schema.graphql",
+            },
+        };
+        const files = processFiles(
+            ["/invalidReferences.js"],
+            config,
+            getFileSource,
+        );
         Object.keys(files).forEach((k: any) => {
             expect(files[k].errors).toEqual([]);
         });
-        const {resolved, errors} = resolveDocuments(files);
+        const {resolved, errors} = resolveDocuments(files, config);
         expect(errors.map((m: any) => m.message)).toMatchInlineSnapshot(`
             Array [
               "Circular import /circular.js -> /invalidReferences.js -> /circular.js",

package/src/parser/__test__/utils.test.ts

@@ -0,0 +1,80 @@
+import fs from "fs";
+import {describe, it, expect, jest} from "@jest/globals";
+import type {Config} from "../../types";
+
+import {getPathWithExtension} from "../utils";
+
+const generate = {
+    match: [/\.fixture\.js$/],
+    exclude: [
+        "_test\\.js$",
+        "\\bcourse-editor-package\\b",
+        "\\.fixture\\.js$",
+        "\\b__flowtests__\\b",
+        "\\bcourse-editor\\b",
+    ],
+    readOnlyArray: false,
+    regenerateCommand: "make gqlflow",
+    scalars: {
+        JSONString: "string",
+        KALocale: "string",
+        NaiveDateTime: "string",
+    },
+    splitTypes: true,
+    generatedDirectory: "__graphql-types__",
+    exportAllObjectTypes: true,
+    schemaFilePath: "./composed_schema.graphql",
+} as const;
+
+const config: Config = {
+    crawl: {
+        root: "/here/we/crawl",
+    },
+    generate: [
+        {...generate, match: [/^static/], exportAllObjectTypes: false},
+        generate,
+    ],
+};
+
+describe("getPathWithExtension", () => {
+    it("should handle a basic missing extension", () => {
+        // Arrange
+        jest.spyOn(fs, "existsSync").mockImplementation((path) =>
+            typeof path === "string" ? path.endsWith(".js") : false,
+        );
+
+        // Act
+        const result = getPathWithExtension("/path/to/file", config);
+
+        // Assert
+        expect(result).toBe("/path/to/file.js");
+    });
+
+    it("returns an empty string if no file is found", () => {
+        // Arrange
+        jest.spyOn(fs, "existsSync").mockImplementation((path) => false);
+
+        // Act
+        const result = getPathWithExtension("/path/to/file", config);
+
+        // Assert
+        expect(result).toBe("");
+    });
+
+    it("maps aliases to their correct value", () => {
+        // Arrange
+        jest.spyOn(fs, "existsSync").mockImplementation((path) =>
+            typeof path === "string" ? path.endsWith(".js") : false,
+        );
+        const tmpConfig: Config = {
+            ...config,
+            alias: [{find: "~", replacement: "../../some/prefix"}],
+        };
+
+        // Act
+        const result = getPathWithExtension("~/dir/file", tmpConfig);
+
+        // Assert
+        expect(result).toBe("../../some/prefix/dir/file.js");
+    });
+});