@khanacademy/graphql-flow 3.4.2 → 4.0.0

package/.github/workflows/changeset-release.yml

@@ -36,7 +36,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Khan/actions@shared-node-cache-v2
+      - uses: Khan/actions@shared-node-cache-v3
         with:
           node-version: 20.x
 

package/.github/workflows/pr-checks.yml

@@ -17,7 +17,7 @@ jobs:
         node-version: [20.x]
     steps:
     - uses: actions/checkout@v4
-    - uses: Khan/actions@shared-node-cache-v2
+    - uses: Khan/actions@shared-node-cache-v3
       with:
         node-version: ${{ matrix.node-version }}
 
@@ -34,7 +34,7 @@ jobs:
 
     - name: Run TypeScript
       if: steps.ts-files.outputs.filtered != '[]'
-      run: yarn typecheck
+      run: pnpm typecheck
 
     - id: eslint-reset
       uses: Khan/actions@filter-files-v1
@@ -47,9 +47,9 @@ jobs:
       uses: Khan/actions@full-or-limited-v0
       with:
         full-trigger: ${{ steps.eslint-reset.outputs.filtered }}
-        full: yarn eslint src/**/*.ts
+        full: pnpm eslint src/**/*.ts
         limited-trigger: ${{ steps.ts-files.outputs.filtered }}
-        limited: yarn eslint {}
+        limited: pnpm eslint {}
 
     - id: jest-reset
       uses: Khan/actions@filter-files-v1
@@ -62,6 +62,6 @@ jobs:
       uses: Khan/actions@full-or-limited-v0
       with:
         full-trigger: ${{ steps.jest-reset.outputs.filtered }}
-        full: yarn jest
+        full: pnpm jest
         limited-trigger: ${{ steps.ts-files.outputs.filtered }}
-        limited: yarn jest --findRelatedTests {}
+        limited: pnpm jest --findRelatedTests {}

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @khanacademy/graphql-flow
 
+## 4.0.0
+
+### Major Changes
+
+-   9d96c11: Overhaul import resolution, relying on tsconfig for import aliases, and rspack-resolver for package imports. This removes the `alias` config option, instead requiring that aliases be defined in a `tsconfig.json`.
+
+### Minor Changes
+
+-   a27caca: Support "export \* from" for fragments
+
 ## 3.4.2
 
 ### Patch Changes

package/dist/cli/run.js

@@ -40,7 +40,7 @@ const inputFiles = (0, _config.getInputFiles)(options, config);
 /** Step (2) */
 
 const files = (0, _parse.processFiles)(inputFiles, config, f => {
-  const resolvedPath = (0, _utils.getPathWithExtension)(f, config);
+  const resolvedPath = (0, _utils.getPathWithExtension)(f);
   if (!resolvedPath) {
     throw new Error(`Unable to find ${f}`);
   }

package/dist/parser/parse.js

@@ -8,6 +8,7 @@ var _wonderStuffCore = require("@khanacademy/wonder-stuff-core");
 var _parser = require("@babel/parser");
 var _traverse = _interopRequireDefault(require("@babel/traverse"));
 var _path = _interopRequireDefault(require("path"));
+var _resolveImport = require("./resolveImport");
 var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
@@ -47,12 +48,12 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * potentially relevant, and of course any values referenced
  * from a graphql template are treated as relevant.
  */
-const listExternalReferences = (file, config) => {
+const listExternalReferences = file => {
   const paths = {};
   const add = (v, followImports) => {
     if (v.type === "import") {
       if (followImports) {
-        const absPath = (0, _utils.getPathWithExtension)(v.path, config);
+        const absPath = (0, _utils.getPathWithExtension)(v.path);
         if (absPath) {
           paths[absPath] = true;
         }
@@ -71,14 +72,15 @@ const listExternalReferences = (file, config) => {
   file.operations.forEach(op => op.source.expressions.forEach(expr => add(expr,
   // Imports that are used in graphql expressions definitely need to be followed.
   true)));
+  file.exportAlls.forEach(expr => add(expr, true));
   return Object.keys(paths);
 };
 const processFile = (filePath, contents, config) => {
-  const dir = _path.default.dirname(filePath);
   const result = {
     path: filePath,
     operations: [],
     exports: {},
+    exportAlls: [],
     locals: {},
     errors: []
   };
@@ -94,14 +96,16 @@ const processFile = (filePath, contents, config) => {
   ast.program.body.forEach(toplevel => {
     var _toplevel$declaration;
     if (toplevel.type === "ImportDeclaration") {
-      const newLocals = getLocals(dir, toplevel, filePath, config);
+      const newLocals = getLocals(toplevel, filePath);
       if (newLocals) {
         Object.keys(newLocals).forEach(k => {
+          var _local$resolvedPath$i, _local$resolvedPath;
           const local = newLocals[k];
-          if (local.path.startsWith("/")) {
+          const isGraphqlTagImport = local.rawPath === "graphql-tag" || ((_local$resolvedPath$i = (_local$resolvedPath = local.resolvedPath) === null || _local$resolvedPath === void 0 ? void 0 : _local$resolvedPath.includes(`${_path.default.sep}node_modules${_path.default.sep}graphql-tag`)) !== null && _local$resolvedPath$i !== void 0 ? _local$resolvedPath$i : false);
+          if (_path.default.isAbsolute(local.path)) {
             result.locals[k] = local;
           }
-          if (local.path === "graphql-tag" && local.name === "default") {
+          if (isGraphqlTagImport && local.name === "default") {
             gqlTagNames.push(k);
           }
         });
@@ -111,7 +115,8 @@ const processFile = (filePath, contents, config) => {
       if (toplevel.source) {
         var _toplevel$specifiers;
         const source = toplevel.source;
-        const importPath = source.value.startsWith(".") ? _path.default.resolve(_path.default.join(dir, source.value)) : source.value;
+        const resolvedPath = (0, _resolveImport.resolveImportPath)(filePath, source.value);
+        const importPath = resolvedPath !== null && resolvedPath !== void 0 ? resolvedPath : source.value;
         (_toplevel$specifiers = toplevel.specifiers) === null || _toplevel$specifiers === void 0 || _toplevel$specifiers.forEach(spec => {
           if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") {
             var _spec$start, _spec$end, _spec$loc$start$line, _spec$loc;
@@ -140,6 +145,22 @@ const processFile = (filePath, contents, config) => {
         });
       }
     }
+    if (toplevel.type === "ExportAllDeclaration" && toplevel.source) {
+      var _toplevel$start, _toplevel$end, _toplevel$loc$start$l, _toplevel$loc;
+      const source = toplevel.source;
+      const importPath = source.value.startsWith(".") ? _path.default.resolve(_path.default.join(_path.default.dirname(filePath), source.value)) : source.value;
+      result.exportAlls.push({
+        type: "import",
+        name: "*",
+        path: importPath,
+        loc: {
+          start: (_toplevel$start = toplevel.start) !== null && _toplevel$start !== void 0 ? _toplevel$start : -1,
+          end: (_toplevel$end = toplevel.end) !== null && _toplevel$end !== void 0 ? _toplevel$end : -1,
+          line: (_toplevel$loc$start$l = (_toplevel$loc = toplevel.loc) === null || _toplevel$loc === void 0 ? void 0 : _toplevel$loc.start.line) !== null && _toplevel$loc$start$l !== void 0 ? _toplevel$loc$start$l : -1,
+          path: filePath
+        }
+      });
+    }
     const processDeclarator = (decl, isExported) => {
       if (decl.id.type !== "Identifier" || !decl.init) {
         return;
@@ -210,7 +231,8 @@ const processFile = (filePath, contents, config) => {
   };
   (0, _traverse.default)(ast, {
     TaggedTemplateExpression(path) {
-      visitTpl(path.node, name => {
+      const node = path.node;
+      visitTpl(node, name => {
         const binding = path.scope.getBinding(name);
         if (!binding) {
           return null;
@@ -273,12 +295,12 @@ const processTemplate = (tpl, result, getTemplate) => {
     }
   };
 };
-const getLocals = (dir, toplevel, myPath, config) => {
+const getLocals = (toplevel, myPath) => {
   if (toplevel.importKind === "type") {
     return null;
   }
-  const fixedPath = (0, _utils.fixPathResolution)(toplevel.source.value, config);
-  const importPath = fixedPath.startsWith(".") ? _path.default.resolve(_path.default.join(dir, fixedPath)) : fixedPath;
+  const resolvedPath = (0, _resolveImport.resolveImportPath)(myPath, toplevel.source.value);
+  const importPath = resolvedPath !== null && resolvedPath !== void 0 ? resolvedPath : toplevel.source.value;
   const locals = {};
   toplevel.specifiers.forEach(spec => {
     if (spec.type === "ImportDefaultSpecifier") {
@@ -286,6 +308,8 @@ const getLocals = (dir, toplevel, myPath, config) => {
         type: "import",
         name: "default",
         path: importPath,
+        rawPath: toplevel.source.value,
+        resolvedPath,
         loc: {
           start: spec.start,
           end: spec.end,
@@ -297,6 +321,8 @@ const getLocals = (dir, toplevel, myPath, config) => {
         type: "import",
         name: spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value,
         path: importPath,
+        rawPath: toplevel.source.value,
+        resolvedPath,
         loc: {
           start: spec.start,
           end: spec.end,
@@ -321,7 +347,7 @@ const processFiles = (filePaths, config, getFileSource) => {
     }
     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);
       }

package/dist/parser/resolve.js

@@ -29,7 +29,7 @@ const resolveDocuments = (files, config) => {
 };
 exports.resolveDocuments = resolveDocuments;
 const resolveImport = (expr, files, errors, seen, config) => {
-  const absPath = (0, _utils.getPathWithExtension)(expr.path, config);
+  const absPath = (0, _utils.getPathWithExtension)(expr.path);
   if (!absPath) {
     return null;
   }
@@ -50,6 +50,19 @@ const resolveImport = (expr, files, errors, seen, config) => {
     return null;
   }
   if (!res.exports[expr.name]) {
+    if (expr.name !== "*" && res.exportAlls.length) {
+      for (const exportAll of res.exportAlls) {
+        const value = resolveImport({
+          ...exportAll,
+          name: expr.name
+        }, files, errors, {
+          ...seen
+        }, config);
+        if (value) {
+          return value;
+        }
+      }
+    }
     errors.push({
       loc: expr.loc,
       message: `${absPath} has no valid gql export ${expr.name}`

package/dist/parser/resolveImport.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetImportCache = resetImportCache;
+exports.resolveImportPath = resolveImportPath;
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _rspackResolver = require("rspack-resolver");
+var _tsconfigPaths = require("tsconfig-paths");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Copied from https://github.com/Khan/frontend/blob/main/libs/node/resolve-import/src/resolve-import.ts
+// In future it would be cool to publish @khan/node-resolve-import as a public library so we
+// could consume it here.
+
+const CONDITION_NAMES = ["import"];
+const matchPathCache = new Map();
+let esmResolver = getEsmResolver();
+function getEsmResolver() {
+  return new _rspackResolver.ResolverFactory({
+    conditionNames: CONDITION_NAMES,
+    mainFields: ["module", "main"],
+    extensions: [".mjs", ".js", ".jsx", ".ts", ".tsx"]
+  });
+}
+function resetImportCache() {
+  matchPathCache.clear();
+  esmResolver = getEsmResolver();
+}
+
+/**
+ * Resolves an import path using tsconfig and the rspack resolver.
+ *
+ * @param sourceFile - The file that is importing the path.
+ * @param importPath - The path to resolve.
+ * @returns The fully resolved path.
+ */
+function resolveImportPath(sourceFile, importPath) {
+  const dir = _nodePath.default.dirname(sourceFile);
+  let matchPath = matchPathCache.get(dir);
+  if (!matchPath) {
+    const foundConfig = (0, _tsconfigPaths.loadConfig)(dir);
+    if (foundConfig.resultType !== "success") {
+      throw new Error("Failed to load tsconfig");
+    }
+    matchPath = (0, _tsconfigPaths.createMatchPath)(foundConfig.absoluteBaseUrl, foundConfig.paths, CONDITION_NAMES);
+    matchPathCache.set(dir, matchPath);
+  }
+
+  // See if we can resolve the import path using the tsconfig.
+  const resolvedPath = matchPath(importPath);
+
+  // Get the directory of the source file to resolve against.
+  const sourceFileDir = _nodePath.default.dirname(sourceFile);
+
+  // Get the fully resolved path.
+  return esmResolver.sync(sourceFileDir, resolvedPath !== null && resolvedPath !== void 0 ? resolvedPath : importPath).path;
+}

package/dist/parser/utils.js

@@ -3,23 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getPathWithExtension = exports.fixPathResolution = void 0;
+exports.getPathWithExtension = void 0;
 var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const fixPathResolution = (path, config) => {
-  if (config.alias) {
-    for (const {
-      find,
-      replacement
-    } of config.alias) {
-      path = path.replace(find, replacement);
-    }
-  }
-  return path;
-};
-exports.fixPathResolution = fixPathResolution;
-const getPathWithExtension = (pathWithoutExtension, config) => {
-  pathWithoutExtension = fixPathResolution(pathWithoutExtension, config);
+const getPathWithExtension = pathWithoutExtension => {
   if (/\.(less|css|png|gif|jpg|jpeg|js|jsx|ts|tsx|mjs)$/.test(pathWithoutExtension)) {
     return pathWithoutExtension;
   }

package/package.json

@@ -1,66 +1,72 @@
 {
-    "name": "@khanacademy/graphql-flow",
-    "version": "3.4.2",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Khan/graphql-flow.git"
-    },
-    "bugs": {
-        "url": "https://github.com/Khan/graphql-flow/issues"
-    },
-    "publishConfig": {
-        "access": "public",
-        "provenance": true
-    },
-    "bin": {
-        "graphql-flow": "dist/cli/run.js"
-    },
-    "jest": {
-        "testPathIgnorePatterns": [
-            "dist"
-        ]
-    },
-    "scripts": {
-        "test": "jest",
-        "typecheck": "tsc --noEmit",
-        "publish:ci": "yarn run build && changeset publish",
-        "build": "babel src --extensions '.ts, .tsx' --out-dir dist --ignore 'src/**/*.spec.ts','src/**/*.test.ts' && chmod 755 dist/cli/run.js"
-    },
-    "main": "dist/index.js",
-    "devDependencies": {
-        "@babel/cli": "^7.17.6",
-        "@babel/eslint-parser": "^7.17.0",
-        "@babel/polyfill": "^7.0.0",
-        "@babel/preset-env": "^7.24.5",
-        "@babel/preset-typescript": "^7.24.1",
-        "@changesets/cli": "^2.21.1",
-        "@khanacademy/eslint-config": "^4.0.0",
-        "@types/jest": "^29.5.3",
-        "@types/prop-types": "^15.7.12",
-        "@types/react": "^18.3.3",
-        "@typescript-eslint/eslint-plugin": "^7.17.0",
-        "@typescript-eslint/parser": "^7.17.0",
-        "babel-jest": "23.4.2",
-        "eslint": "^8.57.0",
-        "eslint-config-prettier": "7.0.0",
-        "eslint-plugin-jest": "^28.6.0",
-        "eslint-plugin-prettier": "^4.0.0",
-        "graphql-tag": "2.10.1",
-        "jest": "^27.5.1",
-        "prettier": "^2.5.1",
-        "prettier-eslint": "^13.0.0",
-        "typescript": "^5.1.6"
-    },
-    "dependencies": {
-        "@babel/core": "^7.24.5",
-        "@babel/generator": "^7.24.5",
-        "@babel/parser": "^7.24.5",
-        "@babel/traverse": "^7.24.5",
-        "@babel/types": "^7.24.5",
-        "@khanacademy/wonder-stuff-core": "^1.5.1",
-        "apollo-utilities": "^1.3.4",
-        "graphql": "^16.9.0",
-        "jsonschema": "^1.4.1",
-        "minimist": "^1.2.8"
-    }
-}
+  "name": "@khanacademy/graphql-flow",
+  "version": "4.0.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Khan/graphql-flow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Khan/graphql-flow/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "bin": {
+    "graphql-flow": "dist/cli/run.js"
+  },
+  "jest": {
+    "testPathIgnorePatterns": [
+      "dist"
+    ]
+  },
+  "main": "dist/index.js",
+  "devDependencies": {
+    "@babel/cli": "^7.17.6",
+    "@babel/eslint-parser": "^7.17.0",
+    "@babel/polyfill": "^7.0.0",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
+    "@changesets/cli": "^2.21.1",
+    "@jest/globals": "^30.2.0",
+    "@khanacademy/eslint-config": "^4.0.0",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/jest": "^29.5.3",
+    "@types/minimist": "^1.2.5",
+    "@types/prop-types": "^15.7.12",
+    "@types/react": "^18.3.3",
+    "@typescript-eslint/eslint-plugin": "^7.17.0",
+    "@typescript-eslint/parser": "^7.17.0",
+    "babel-jest": "23.4.2",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "7.0.0",
+    "eslint-plugin-jest": "^28.6.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "graphql-tag": "2.10.1",
+    "jest": "^27.5.1",
+    "prettier": "^2.5.1",
+    "prettier-eslint": "^13.0.0",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@babel/core": "^7.24.5",
+    "@babel/generator": "^7.24.5",
+    "@babel/parser": "^7.24.5",
+    "@babel/traverse": "^7.24.5",
+    "@babel/types": "^7.24.5",
+    "@khanacademy/wonder-stuff-core": "^1.5.1",
+    "apollo-utilities": "^1.3.4",
+    "graphql": "^16.9.0",
+    "jsonschema": "^1.4.1",
+    "minimist": "^1.2.8",
+    "rspack-resolver": "^1.3.0",
+    "tsconfig-paths": "^4.2.0"
+  },
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "publish:ci": "pnpm build && changeset publish",
+    "build": "babel src --extensions '.ts, .tsx' --out-dir dist --ignore 'src/**/*.spec.ts','src/**/*.test.ts' && chmod 755 dist/cli/run.js"
+  }
+}

package/schema.json

@@ -94,23 +94,7 @@
         "generate": {"oneOf": [
             {"$ref": "#/definitions/GenerateConfig"},
             {"type": "array", "items": {"$ref": "#/definitions/GenerateConfig"}}
-        ]},
-        "alias": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "additionalProperties": false,
-                "properties": {
-                    "find": {
-                        "type": ["string", "object"]
-                    },
-                    "replacement": {
-                        "type": "string"
-                    }
-                },
-                "required": [ "find", "replacement" ]
-            }
-        }
+        ]}
     },
     "required": [ "crawl", "generate" ]
 }

package/src/cli/run.ts

@@ -56,7 +56,7 @@ const inputFiles = getInputFiles(options, config);
 /** Step (2) */
 
 const files = processFiles(inputFiles, config, (f) => {
-    const resolvedPath = getPathWithExtension(f, config);
+    const resolvedPath = getPathWithExtension(f);
     if (!resolvedPath) {
         throw new Error(`Unable to find ${f}`);
     }

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';
@@ -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;
     };
@@ -100,15 +105,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 +143,7 @@ const listExternalReferences = (
             ),
         ),
     );
+    file.exportAlls.forEach((expr) => add(expr, true));
     return Object.keys(paths);
 };
 
@@ -154,11 +157,11 @@ export const processFile = (
           },
     config: Config,
 ): FileResult => {
-    const dir = path.dirname(filePath);
     const result: FileResult = {
         path: filePath,
         operations: [],
         exports: {},
+        exportAlls: [],
         locals: {},
         errors: [],
     };
@@ -178,17 +181,20 @@ export const processFile = (
 
     ast.program.body.forEach((toplevel) => {
         if (toplevel.type === "ImportDeclaration") {
-            const newLocals = getLocals(dir, toplevel, filePath, config);
+            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 +203,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 +234,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 +330,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;
@@ -384,10 +407,8 @@ const processTemplate = (
 };
 
 const getLocals = (
-    dir: string,
     toplevel: ImportDeclaration,
     myPath: string,
-    config: Config,
 ):
     | {
           [key: string]: Import;
@@ -397,10 +418,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 +427,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 +439,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 +472,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);
             }

package/src/parser/resolve.ts

@@ -51,7 +51,7 @@ const resolveImport = (
     },
     config: Config,
 ): Document | null | undefined => {
-    const absPath = getPathWithExtension(expr.path, config);
+    const absPath = getPathWithExtension(expr.path);
     if (!absPath) {
         return null;
     }
@@ -71,6 +71,23 @@ const resolveImport = (
         return null;
     }
     if (!res.exports[expr.name]) {
+        if (expr.name !== "*" && res.exportAlls.length) {
+            for (const exportAll of res.exportAlls) {
+                const value = resolveImport(
+                    {
+                        ...exportAll,
+                        name: expr.name,
+                    },
+                    files,
+                    errors,
+                    {...seen},
+                    config,
+                );
+                if (value) {
+                    return value;
+                }
+            }
+        }
         errors.push({
             loc: expr.loc,
             message: `${absPath} has no valid gql export ${expr.name}`,

package/src/parser/resolveImport.ts

@@ -0,0 +1,65 @@
+// Copied from https://github.com/Khan/frontend/blob/main/libs/node/resolve-import/src/resolve-import.ts
+// In future it would be cool to publish @khan/node-resolve-import as a public library so we
+// could consume it here.
+import path from "node:path";
+
+import {ResolverFactory} from "rspack-resolver";
+import {createMatchPath, loadConfig} from "tsconfig-paths";
+
+const CONDITION_NAMES = ["import"];
+
+const matchPathCache = new Map<
+    string,
+    (importPath: string) => string | undefined
+>();
+
+let esmResolver = getEsmResolver();
+
+function getEsmResolver() {
+    return new ResolverFactory({
+        conditionNames: CONDITION_NAMES,
+        mainFields: ["module", "main"],
+        extensions: [".mjs", ".js", ".jsx", ".ts", ".tsx"],
+    });
+}
+
+export function resetImportCache() {
+    matchPathCache.clear();
+    esmResolver = getEsmResolver();
+}
+
+/**
+ * Resolves an import path using tsconfig and the rspack resolver.
+ *
+ * @param sourceFile - The file that is importing the path.
+ * @param importPath - The path to resolve.
+ * @returns The fully resolved path.
+ */
+export function resolveImportPath(sourceFile: string, importPath: string) {
+    const dir = path.dirname(sourceFile);
+    let matchPath = matchPathCache.get(dir);
+
+    if (!matchPath) {
+        const foundConfig = loadConfig(dir);
+
+        if (foundConfig.resultType !== "success") {
+            throw new Error("Failed to load tsconfig");
+        }
+
+        matchPath = createMatchPath(
+            foundConfig.absoluteBaseUrl,
+            foundConfig.paths,
+            CONDITION_NAMES,
+        );
+        matchPathCache.set(dir, matchPath);
+    }
+
+    // See if we can resolve the import path using the tsconfig.
+    const resolvedPath = matchPath(importPath);
+
+    // Get the directory of the source file to resolve against.
+    const sourceFileDir = path.dirname(sourceFile);
+
+    // Get the fully resolved path.
+    return esmResolver.sync(sourceFileDir, resolvedPath ?? importPath).path;
+}

package/src/parser/utils.ts

@@ -1,20 +1,6 @@
 import fs from "fs";
-import {Config} from "../types";
 
-export const fixPathResolution = (path: string, config: Config) => {
-    if (config.alias) {
-        for (const {find, replacement} of config.alias) {
-            path = path.replace(find, replacement);
-        }
-    }
-    return path;
-};
-
-export const getPathWithExtension = (
-    pathWithoutExtension: string,
-    config: Config,
-) => {
-    pathWithoutExtension = fixPathResolution(pathWithoutExtension, config);
+export const getPathWithExtension = (pathWithoutExtension: string) => {
     if (
         /\.(less|css|png|gif|jpg|jpeg|js|jsx|ts|tsx|mjs)$/.test(
             pathWithoutExtension,

package/src/types.ts

@@ -50,10 +50,6 @@ export type CrawlConfig = {
 export type Config = {
     crawl: CrawlConfig;
     generate: GenerateConfig | Array<GenerateConfig>;
-    alias?: Array<{
-        find: RegExp | string;
-        replacement: string;
-    }>;
 };
 
 export type Schema = {