@khanacademy/graphql-flow 3.4.2 → 4.0.1

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

@@ -1,4 +1,7 @@
-import {describe, it, expect} from "@jest/globals";
+/**
+ * @jest-environment node
+ */
+import {describe, it, expect, afterEach} from "@jest/globals";
 
 import {Config} from "../../types";
 import {processFiles} from "../parse";
@@ -6,6 +9,32 @@ import {resolveDocuments} from "../resolve";
 
 import {print} from "graphql/language/printer";
 
+jest.mock("../resolveImport", () => ({
+    resetImportCache: jest.fn(),
+    resolveImportPath: jest
+        .fn()
+        .mockImplementation((sourceFile: string, importPath: string) => {
+            const path = require("path");
+            if (importPath === "graphql-tag") {
+                return "/repo/node_modules/graphql-tag/index.js";
+            }
+            if (importPath === "monorepo-package/fragment") {
+                return "/repo/node_modules/monorepo-package/fragment.js";
+            }
+            if (importPath.startsWith(".")) {
+                return path.resolve(path.dirname(sourceFile), importPath);
+            }
+            if (path.isAbsolute(importPath)) {
+                return importPath;
+            }
+            return null;
+        }),
+}));
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
 const fixtureFiles: {
     [key: string]:
         | string
@@ -14,6 +43,27 @@ const fixtureFiles: {
               resolvedPath: string;
           };
 } = {
+    "/repo/node_modules/monorepo-package/fragment.js": `
+        import gql from 'graphql-tag';
+
+        export const sharedFragment = gql\`
+        fragment SharedFields on Something {
+            id
+        }
+        \`;
+    `,
+    "/repo/packages/app/App.js": `
+        import gql from 'graphql-tag';
+        import {sharedFragment} from 'monorepo-package/fragment';
+        export const appQuery = gql\`
+        query AppQuery {
+            viewer {
+                ...SharedFields
+            }
+        }
+        \${sharedFragment}
+        \`;
+    `,
     "/firstFile.js": `
         // Note that you can import graphql-tag as
         // something other than gql.
@@ -57,6 +107,31 @@ const fixtureFiles: {
         \`;
         export {secondFragment};`,
 
+    "/starExportSource.js": `
+        import gql from 'graphql-tag';
+        export const starFragment = gql\`
+        fragment StarFragment on Star {
+            id
+        }
+        \`;
+    `,
+    "/starExportReexport.js": `
+        export * from './starExportSource.js';
+    `,
+    "/starExportConsumer.js": `
+        import gql from 'graphql-tag';
+        import {starFragment} from './starExportReexport.js';
+
+        export const starQuery = gql\`
+        query StarQuery {
+            stars {
+                ...StarFragment
+            }
+        }
+        \${starFragment}
+        \`;
+    `,
+
     "/thirdFile.js": `
         import {fromFirstFile, alsoFirst, secondFragment} from './secondFile.js';
         import gql from 'graphql-tag';
@@ -281,7 +356,7 @@ describe("processing fragments in various ways", () => {
         expect(files["/invalidThings.js"].errors.map((m: any) => m.message))
             .toMatchInlineSnapshot(`
             Array [
-              "Unable to resolve someExternalFragment",
+              "Unable to resolve import someExternalFragment from \\"somewhere\\" at /invalidThings.js:4.",
               "Unable to resolve someUndefinedFragment",
               "Template literal interpolation must be an identifier",
             ]
@@ -338,4 +413,123 @@ describe("processing fragments in various ways", () => {
         );
         expect(printed).toMatchInlineSnapshot(`Object {}`);
     });
+
+    it("should resolve fragments re-exported via export all", () => {
+        // Arrange
+        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",
+            },
+        };
+        // Act
+        const files = processFiles(
+            ["/starExportConsumer.js"],
+            config,
+            getFileSource,
+        );
+        const {resolved} = resolveDocuments(files, config);
+        const printed: Record<string, any> = {};
+        Object.keys(resolved).map(
+            (k: any) => (printed[k] = print(resolved[k].document).trim()),
+        );
+
+        // Assert
+        expect(printed).toMatchInlineSnapshot(`
+            Object {
+              "/starExportConsumer.js:5": "query StarQuery {
+              stars {
+                ...StarFragment
+              }
+            }
+
+            fragment StarFragment on Star {
+              id
+            }",
+              "/starExportSource.js:3": "fragment StarFragment on Star {
+              id
+            }",
+            }
+        `);
+    });
+
+    it("should resolve fragments imported from monorepo packages", () => {
+        // Arrange
+        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",
+            },
+        };
+
+        // Act
+        const files = processFiles(
+            ["/repo/packages/app/App.js"],
+            config,
+            getFileSource,
+        );
+        const {resolved} = resolveDocuments(files, config);
+        const printed: Record<string, any> = {};
+        Object.keys(resolved).map(
+            (k: any) => (printed[k] = print(resolved[k].document).trim()),
+        );
+
+        // Assert
+        expect(printed).toMatchInlineSnapshot(`
+                Object {
+                  "/repo/node_modules/monorepo-package/fragment.js:4": "fragment SharedFields on Something {
+                  id
+                }",
+                  "/repo/packages/app/App.js:4": "query AppQuery {
+                  viewer {
+                    ...SharedFields
+                  }
+                }
+
+                fragment SharedFields on Something {
+                  id
+                }",
+                }
+            `);
+    });
 });

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

@@ -0,0 +1,98 @@
+/**
+ * @jest-environment node
+ */
+import {afterEach, beforeEach, describe, expect, it} from "@jest/globals";
+import {resolveImportPath, resetImportCache} from "../resolveImport";
+import {ResolverFactory} from "rspack-resolver";
+
+const mockSync = jest.fn();
+const mockCreateMatchPath = jest.fn();
+const mockLoadConfig = jest.fn();
+
+jest.mock("rspack-resolver", () => ({
+    ResolverFactory: jest.fn().mockImplementation(() => ({
+        sync: (...args: Array<unknown>) => mockSync(...args),
+    })),
+}));
+
+jest.mock("tsconfig-paths", () => ({
+    createMatchPath: jest
+        .fn()
+        .mockImplementation((...args: Array<unknown>) =>
+            mockCreateMatchPath(...args),
+        ),
+    loadConfig: jest
+        .fn()
+        .mockImplementation((...args: Array<unknown>) =>
+            mockLoadConfig(...args),
+        ),
+}));
+
+describe("resolveImportPath", () => {
+    beforeEach(() => {
+        mockSync.mockReset();
+        mockCreateMatchPath.mockReset();
+        mockLoadConfig.mockReset();
+        (ResolverFactory as unknown as jest.Mock).mockClear();
+        resetImportCache();
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("returns the resolved path from the resolver", () => {
+        // Arrange
+        const matchPath = jest.fn().mockReturnValue("/repo/src/alias/thing.ts");
+        mockLoadConfig.mockReturnValue({
+            resultType: "success",
+            absoluteBaseUrl: "/repo",
+            paths: {"@/*": ["src/*"]},
+        });
+        mockCreateMatchPath.mockReturnValue(matchPath);
+        mockSync.mockReturnValue({path: "/repo/src/alias/thing.ts"});
+
+        // Act
+        const result = resolveImportPath("/repo/src/file.ts", "@/alias/thing");
+
+        // Assert
+        expect(result).toBe("/repo/src/alias/thing.ts");
+    });
+
+    it("loads tsconfig from the source file directory", () => {
+        // Arrange
+        const matchPath = jest.fn().mockReturnValue("/repo/src/alias/thing.ts");
+        mockLoadConfig.mockReturnValue({
+            resultType: "success",
+            absoluteBaseUrl: "/repo",
+            paths: {"@/*": ["src/*"]},
+        });
+        mockCreateMatchPath.mockReturnValue(matchPath);
+        mockSync.mockReturnValue({path: "/repo/src/alias/thing.ts"});
+
+        // Act
+        resolveImportPath("/repo/src/file.ts", "@/alias/thing");
+
+        // Assert
+        expect(mockLoadConfig).toHaveBeenCalledWith("/repo/src");
+    });
+
+    it("caches tsconfig matchPath per source directory", () => {
+        // Arrange
+        const matchPath = jest.fn().mockReturnValue(undefined);
+        mockLoadConfig.mockReturnValue({
+            resultType: "success",
+            absoluteBaseUrl: "/repo",
+            paths: {},
+        });
+        mockCreateMatchPath.mockReturnValue(matchPath);
+        mockSync.mockReturnValue({path: "/repo/node_modules/pkg/index.js"});
+
+        // Act
+        resolveImportPath("/repo/src/a.ts", "pkg");
+        resolveImportPath("/repo/src/b.ts", "pkg");
+
+        // Assert
+        expect(mockLoadConfig).toHaveBeenCalledTimes(1);
+    });
+});

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

@@ -1,41 +1,10 @@
+/**
+ * @jest-environment node
+ */
 import fs from "fs";
-import {describe, it, expect, jest} from "@jest/globals";
-import type {Config} from "../../types";
-
+import {describe, it, expect} from "@jest/globals";
 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
@@ -44,7 +13,7 @@ describe("getPathWithExtension", () => {
         );
 
         // Act
-        const result = getPathWithExtension("/path/to/file", config);
+        const result = getPathWithExtension("/path/to/file");
 
         // Assert
         expect(result).toBe("/path/to/file.js");
@@ -55,26 +24,20 @@ describe("getPathWithExtension", () => {
         jest.spyOn(fs, "existsSync").mockImplementation((path) => false);
 
         // Act
-        const result = getPathWithExtension("/path/to/file", config);
+        const result = getPathWithExtension("/path/to/file");
 
         // Assert
         expect(result).toBe(null);
     });
 
-    it("maps aliases to their correct value", () => {
+    it("returns the original path when an extension is already present", () => {
         // Arrange
-        jest.spyOn(fs, "existsSync").mockImplementation((path) =>
-            typeof path === "string" ? path.endsWith(".js") : false,
-        );
-        const tmpConfig: Config = {
-            ...config,
-            alias: [{find: "~", replacement: "../../some/prefix"}],
-        };
+        const input = "/dir/file.tsx";
 
         // Act
-        const result = getPathWithExtension("~/dir/file", tmpConfig);
+        const result = getPathWithExtension(input);
 
         // Assert
-        expect(result).toBe("../../some/prefix/dir/file.js");
+        expect(result).toBe(input);
     });
 });

package/src/parser/parse.ts

@@ -8,10 +8,12 @@ import type {
 
 import {parse, ParserPlugin} from "@babel/parser";
 import traverse from "@babel/traverse";
+import type {NodePath} from "@babel/traverse";
 
 import path from "path";
 
-import {fixPathResolution, getPathWithExtension} from "./utils";
+import {resolveImportPath} from "./resolveImport";
+import {getPathWithExtension} from "./utils";
 import {Config} from "../types";
 
 /**
@@ -63,6 +65,8 @@ export type Import = {
     type: "import";
     name: string;
     path: string;
+    rawPath?: string;
+    resolvedPath?: string | null;
     loc: Loc;
 };
 
@@ -79,6 +83,7 @@ export type FileResult = {
     exports: {
         [key: string]: Document | Import;
     };
+    exportAlls: Array<Import>;
     locals: {
         [key: string]: Document | Import;
     };
@@ -86,6 +91,12 @@ export type FileResult = {
         loc: Loc;
         message: string;
     }>;
+    unresolvedImports?: {
+        [key: string]: {
+            source: string;
+            loc: Loc;
+        };
+    };
 };
 
 export type Files = {
@@ -100,15 +111,12 @@ export type Files = {
  * potentially relevant, and of course any values referenced
  * from a graphql template are treated as relevant.
  */
-const listExternalReferences = (
-    file: FileResult,
-    config: Config,
-): Array<string> => {
+const listExternalReferences = (file: FileResult): Array<string> => {
     const paths: Record<string, any> = {};
     const add = (v: Document | Import, followImports: boolean) => {
         if (v.type === "import") {
             if (followImports) {
-                const absPath = getPathWithExtension(v.path, config);
+                const absPath = getPathWithExtension(v.path);
                 if (absPath) {
                     paths[absPath] = true;
                 }
@@ -141,6 +149,7 @@ const listExternalReferences = (
             ),
         ),
     );
+    file.exportAlls.forEach((expr) => add(expr, true));
     return Object.keys(paths);
 };
 
@@ -154,13 +163,14 @@ export const processFile = (
           },
     config: Config,
 ): FileResult => {
-    const dir = path.dirname(filePath);
     const result: FileResult = {
         path: filePath,
         operations: [],
         exports: {},
+        exportAlls: [],
         locals: {},
         errors: [],
+        unresolvedImports: {},
     };
     const text = typeof contents === "string" ? contents : contents.text;
     const plugins: Array<ParserPlugin> = filePath.endsWith("x")
@@ -178,17 +188,42 @@ export const processFile = (
 
     ast.program.body.forEach((toplevel) => {
         if (toplevel.type === "ImportDeclaration") {
-            const newLocals = getLocals(dir, toplevel, filePath, config);
+            const isUnresolvedModule =
+                !toplevel.source.value.startsWith(".") &&
+                !path.isAbsolute(toplevel.source.value) &&
+                toplevel.source.value !== "graphql-tag";
+            if (isUnresolvedModule) {
+                toplevel.specifiers.forEach((spec) => {
+                    if (
+                        spec.type === "ImportSpecifier" ||
+                        spec.type === "ImportDefaultSpecifier"
+                    ) {
+                        result.unresolvedImports![spec.local.name] = {
+                            source: toplevel.source.value,
+                            loc: {
+                                start: spec.start ?? -1,
+                                end: spec.end ?? -1,
+                                line: spec.loc?.start.line ?? -1,
+                                path: filePath,
+                            },
+                        };
+                    }
+                });
+            }
+            const newLocals = getLocals(toplevel, filePath);
             if (newLocals) {
                 Object.keys(newLocals).forEach((k) => {
                     const local = newLocals[k];
-                    if (local.path.startsWith("/")) {
+                    const isGraphqlTagImport =
+                        local.rawPath === "graphql-tag" ||
+                        (local.resolvedPath?.includes(
+                            `${path.sep}node_modules${path.sep}graphql-tag`,
+                        ) ??
+                            false);
+                    if (path.isAbsolute(local.path)) {
                         result.locals[k] = local;
                     }
-                    if (
-                        local.path === "graphql-tag" &&
-                        local.name === "default"
-                    ) {
+                    if (isGraphqlTagImport && local.name === "default") {
                         gqlTagNames.push(k);
                     }
                 });
@@ -197,9 +232,8 @@ export const processFile = (
         if (toplevel.type === "ExportNamedDeclaration") {
             if (toplevel.source) {
                 const source = toplevel.source;
-                const importPath = source.value.startsWith(".")
-                    ? path.resolve(path.join(dir, source.value))
-                    : source.value;
+                const resolvedPath = resolveImportPath(filePath, source.value);
+                const importPath = resolvedPath ?? source.value;
                 toplevel.specifiers?.forEach((spec) => {
                     if (
                         spec.type === "ExportSpecifier" &&
@@ -229,6 +263,23 @@ export const processFile = (
                 });
             }
         }
+        if (toplevel.type === "ExportAllDeclaration" && toplevel.source) {
+            const source = toplevel.source;
+            const importPath = source.value.startsWith(".")
+                ? path.resolve(path.join(path.dirname(filePath), source.value))
+                : source.value;
+            result.exportAlls.push({
+                type: "import",
+                name: "*",
+                path: importPath,
+                loc: {
+                    start: toplevel.start ?? -1,
+                    end: toplevel.end ?? -1,
+                    line: toplevel.loc?.start.line ?? -1,
+                    path: filePath,
+                },
+            });
+        }
 
         const processDeclarator = (
             decl: VariableDeclarator,
@@ -308,8 +359,9 @@ export const processFile = (
     };
 
     traverse(ast as any, {
-        TaggedTemplateExpression(path) {
-            visitTpl(path.node as any, (name) => {
+        TaggedTemplateExpression(path: NodePath) {
+            const node = path.node as TaggedTemplateExpression;
+            visitTpl(node, (name) => {
                 const binding = path.scope.getBinding(name);
                 if (!binding) {
                     return null;
@@ -358,10 +410,18 @@ const processTemplate = (
                     const found = getTemplate(expr.name);
                     return found;
                 }
-                result.errors.push({
-                    loc,
-                    message: `Unable to resolve ${expr.name}`,
-                });
+                const unresolved = result.unresolvedImports?.[expr.name];
+                if (unresolved) {
+                    result.errors.push({
+                        loc: unresolved.loc,
+                        message: `Unable to resolve import ${expr.name} from "${unresolved.source}" at ${unresolved.loc.path}:${unresolved.loc.line}.`,
+                    });
+                } else {
+                    result.errors.push({
+                        loc,
+                        message: `Unable to resolve ${expr.name}`,
+                    });
+                }
                 return null;
             }
             return result.locals[expr.name];
@@ -384,10 +444,8 @@ const processTemplate = (
 };
 
 const getLocals = (
-    dir: string,
     toplevel: ImportDeclaration,
     myPath: string,
-    config: Config,
 ):
     | {
           [key: string]: Import;
@@ -397,10 +455,8 @@ const getLocals = (
     if (toplevel.importKind === "type") {
         return null;
     }
-    const fixedPath = fixPathResolution(toplevel.source.value, config);
-    const importPath = fixedPath.startsWith(".")
-        ? path.resolve(path.join(dir, fixedPath))
-        : fixedPath;
+    const resolvedPath = resolveImportPath(myPath, toplevel.source.value);
+    const importPath = resolvedPath ?? toplevel.source.value;
     const locals: Record<string, any> = {};
     toplevel.specifiers.forEach((spec) => {
         if (spec.type === "ImportDefaultSpecifier") {
@@ -408,6 +464,8 @@ const getLocals = (
                 type: "import",
                 name: "default",
                 path: importPath,
+                rawPath: toplevel.source.value,
+                resolvedPath,
                 loc: {start: spec.start, end: spec.end, path: myPath},
             };
         } else if (spec.type === "ImportSpecifier") {
@@ -418,6 +476,8 @@ const getLocals = (
                         ? spec.imported.name
                         : spec.imported.value,
                 path: importPath,
+                rawPath: toplevel.source.value,
+                resolvedPath,
                 loc: {start: spec.start, end: spec.end, path: myPath},
             };
         }
@@ -449,7 +509,7 @@ export const processFiles = (
         }
         const result = processFile(next, source, config);
         files[next] = result;
-        listExternalReferences(result, config).forEach((path) => {
+        listExternalReferences(result).forEach((path) => {
             if (!files[path] && !toProcess.includes(path)) {
                 toProcess.push(path);
             }