@khanacademy/graphql-flow 3.0.1 → 3.1.1

package/src/parser/parse.ts

@@ -1,17 +1,18 @@
-import {isTruthy} from '@khanacademy/wonder-stuff-core';
+import {isTruthy} from "@khanacademy/wonder-stuff-core";
 import type {
-    BabelNodeImportDeclaration,
-    BabelNodeVariableDeclarator,
-    BabelNodeTaggedTemplateExpression,
-    BabelNodeFile,
-} from '@babel/types';
+    ImportDeclaration,
+    VariableDeclarator,
+    TaggedTemplateExpression,
+    File,
+} from "@babel/types";
 
-import {parse} from '@babel/parser'; // eslint-disable-line flowtype-errors/uncovered
-import traverse from '@babel/traverse'; // eslint-disable-line flowtype-errors/uncovered
+import {parse, ParserPlugin} from "@babel/parser";
+import traverse from "@babel/traverse";
 
-import path from 'path';
+import path from "path";
 
-import {getPathWithExtension} from './utils';
+import {fixPathResolution, getPathWithExtension} from "./utils";
+import {Config} from "../types";
 
 /**
  * This file is responsible for finding all gql`-annotated
@@ -43,52 +44,52 @@ import {getPathWithExtension} from './utils';
  */
 
 export type Template = {
-    literals: Array<string>
-    expressions: Array<Document | Import>
-    loc: Loc
+    literals: Array<string>;
+    expressions: Array<Document | Import>;
+    loc: Loc;
 };
 export type Loc = {
-    start: number
-    end: number
-    path: string
-    line: number
+    start: number;
+    end: number;
+    path: string;
+    line: number;
 };
 
 export type Document = {
-    type: 'document'
-    source: Template
+    type: "document";
+    source: Template;
 };
 export type Import = {
-    type: 'import'
-    name: string
-    path: string
-    loc: Loc
+    type: "import";
+    name: string;
+    path: string;
+    loc: Loc;
 };
 
 export type Operation = {
-    source: Template
+    source: Template;
     // TODO: Determine if an operation is already wrapped
     // in `gqlOp` so we can automatically wrap if needed.
     // needsWrapping: boolean,
 };
 
 export type FileResult = {
-    path: string
-    operations: Array<Operation>
+    path: string;
+    operations: Array<Operation>;
     exports: {
-        [key: string]: Document | Import
-    }
+        [key: string]: Document | Import;
+    };
     locals: {
-        [key: string]: Document | Import
-    }
+        [key: string]: Document | Import;
+    };
     errors: Array<{
-        loc: Loc
-        message: string
-    }>
+        loc: Loc;
+        message: string;
+    }>;
 };
 
 export type Files = {
-    [path: string]: FileResult
+    [path: string]: FileResult;
 };
 
 /**
@@ -99,12 +100,15 @@ export type Files = {
  * potentially relevant, and of course any values referenced
  * from a graphql template are treated as relevant.
  */
-const listExternalReferences = (file: FileResult): Array<string> => {
+const listExternalReferences = (
+    file: FileResult,
+    config: Config,
+): Array<string> => {
     const paths: Record<string, any> = {};
     const add = (v: Document | Import, followImports: boolean) => {
-        if (v.type === 'import') {
+        if (v.type === "import") {
             if (followImports) {
-                const absPath = getPathWithExtension(v.path);
+                const absPath = getPathWithExtension(v.path, config);
                 if (absPath) {
                     paths[absPath] = true;
                 }
@@ -142,10 +146,13 @@ const listExternalReferences = (file: FileResult): Array<string> => {
 
 export const processFile = (
     filePath: string,
-    contents: string | {
-        text: string
-        resolvedPath: string
-    },
+    contents:
+        | string
+        | {
+              text: string;
+              resolvedPath: string;
+          },
+    config: Config,
 ): FileResult => {
     const dir = path.dirname(filePath);
     const result: FileResult = {
@@ -155,55 +162,51 @@ export const processFile = (
         locals: {},
         errors: [],
     };
-    const resolved =
-        typeof contents === 'string' ? filePath : contents.resolvedPath;
-    const text = typeof contents === 'string' ? contents : contents.text;
-    const plugins = resolved.match(/\.tsx?$/)
-        ? ['typescript', filePath.endsWith('x') ? 'jsx' : null].filter(isTruthy)
-        : [['flow', {enums: true}], 'jsx'];
-    /* eslint-disable flowtype-errors/uncovered */
-    const ast: BabelNodeFile = parse(text, {
-        sourceType: 'module',
+    const text = typeof contents === "string" ? contents : contents.text;
+    const plugins: Array<ParserPlugin> = filePath.endsWith("x")
+        ? ["typescript", "jsx"]
+        : ["typescript"];
+    const ast: File = parse(text, {
+        sourceType: "module",
         allowImportExportEverywhere: true,
         plugins: plugins,
     });
-    /* eslint-enable flowtype-errors/uncovered */
-    const gqlTagNames = [];
+    const gqlTagNames: Array<string> = [];
     const seenTemplates: {
-        [key: number]: Document | false
+        [key: number]: Document | false;
     } = {};
 
     ast.program.body.forEach((toplevel) => {
-        if (toplevel.type === 'ImportDeclaration') {
-            const newLocals = getLocals(dir, toplevel, filePath);
+        if (toplevel.type === "ImportDeclaration") {
+            const newLocals = getLocals(dir, toplevel, filePath, config);
             if (newLocals) {
                 Object.keys(newLocals).forEach((k) => {
                     const local = newLocals[k];
-                    if (local.path.startsWith('/')) {
+                    if (local.path.startsWith("/")) {
                         result.locals[k] = local;
                     }
                     if (
-                        local.path === 'graphql-tag' &&
-                        local.name === 'default'
+                        local.path === "graphql-tag" &&
+                        local.name === "default"
                     ) {
                         gqlTagNames.push(k);
                     }
                 });
             }
         }
-        if (toplevel.type === 'ExportNamedDeclaration') {
+        if (toplevel.type === "ExportNamedDeclaration") {
             if (toplevel.source) {
                 const source = toplevel.source;
-                const importPath = source.value.startsWith('.')
+                const importPath = source.value.startsWith(".")
                     ? path.resolve(path.join(dir, source.value))
                     : source.value;
-                toplevel.specifiers?.forEach((spec: unknown) => {
+                toplevel.specifiers?.forEach((spec) => {
                     if (
-                        spec.type === 'ExportSpecifier' &&
-                        spec.exported.type === 'Identifier'
+                        spec.type === "ExportSpecifier" &&
+                        spec.exported.type === "Identifier"
                     ) {
                         result.exports[spec.exported.name] = {
-                            type: 'import',
+                            type: "import",
                             name: spec.local.name,
                             path: importPath,
                             loc: {
@@ -216,10 +219,10 @@ export const processFile = (
                     }
                 });
             } else {
-                toplevel.specifiers?.forEach((spec: unknown) => {
-                    if (spec.type === 'ExportSpecifier') {
+                toplevel.specifiers?.forEach((spec) => {
+                    if (spec.type === "ExportSpecifier") {
                         const local = result.locals[spec.local.name];
-                        if (local && spec.exported.type === 'Identifier') {
+                        if (local && spec.exported.type === "Identifier") {
                             result.exports[spec.exported.name] = local;
                         }
                     }
@@ -228,23 +231,23 @@ export const processFile = (
         }
 
         const processDeclarator = (
-            decl: BabelNodeVariableDeclarator,
+            decl: VariableDeclarator,
             isExported: boolean,
         ) => {
-            if (decl.id.type !== 'Identifier' || !decl.init) {
+            if (decl.id.type !== "Identifier" || !decl.init) {
                 return;
             }
             const {init} = decl;
             const id = decl.id.name;
             if (
-                init.type === 'TaggedTemplateExpression' &&
-                init.tag.type === 'Identifier'
+                init.type === "TaggedTemplateExpression" &&
+                init.tag.type === "Identifier"
             ) {
                 if (gqlTagNames.includes(init.tag.name)) {
                     const tpl = processTemplate(init, result);
                     if (tpl) {
                         const document = (result.locals[id] = {
-                            type: 'document',
+                            type: "document",
                             source: tpl,
                         });
                         seenTemplates[init.start ?? -1] = document;
@@ -256,7 +259,7 @@ export const processFile = (
                     }
                 }
             }
-            if (init.type === 'Identifier' && result.locals[init.name]) {
+            if (init.type === "Identifier" && result.locals[init.name]) {
                 result.locals[id] = result.locals[init.name];
                 if (isExported) {
                     result.exports[id] = result.locals[init.name];
@@ -264,15 +267,15 @@ export const processFile = (
             }
         };
 
-        if (toplevel.type === 'VariableDeclaration') {
+        if (toplevel.type === "VariableDeclaration") {
             toplevel.declarations.forEach((decl) => {
                 processDeclarator(decl, false);
             });
         }
 
         if (
-            toplevel.type === 'ExportNamedDeclaration' &&
-            toplevel.declaration?.type === 'VariableDeclaration'
+            toplevel.type === "ExportNamedDeclaration" &&
+            toplevel.declaration?.type === "VariableDeclaration"
         ) {
             toplevel.declaration.declarations.forEach((decl) => {
                 processDeclarator(decl, true);
@@ -281,21 +284,21 @@ export const processFile = (
     });
 
     const visitTpl = (
-        node: BabelNodeTaggedTemplateExpression,
+        node: TaggedTemplateExpression,
         getBinding: (name: string) => Document | null,
     ) => {
         if (seenTemplates[node.start ?? -1] != null) {
             return;
         }
         if (
-            node.tag.type !== 'Identifier' ||
+            node.tag.type !== "Identifier" ||
             !gqlTagNames.includes(node.tag.name)
         ) {
             return;
         }
         const tpl = processTemplate(node, result, getBinding);
         if (tpl) {
-            seenTemplates[node.start ?? -1] = {type: 'document', source: tpl};
+            seenTemplates[node.start ?? -1] = {type: "document", source: tpl};
             result.operations.push({
                 source: tpl,
             });
@@ -304,35 +307,37 @@ export const processFile = (
         }
     };
 
-    /* eslint-disable flowtype-errors/uncovered */
     traverse(ast, {
-        TaggedTemplateExpression(path: unknown) {
+        TaggedTemplateExpression(path) {
             visitTpl(path.node, (name) => {
                 const binding = path.scope.getBinding(name);
-                const start = binding.path.node.init
-                    ? binding.path.node.init.start
-                    : null;
+                if (!binding) {
+                    return null;
+                }
+                const start =
+                    "init" in binding.path.node && binding.path.node.init
+                        ? binding.path.node.init.start
+                        : null;
                 if (start && seenTemplates[start]) {
-                    return seenTemplates[start];
+                    return seenTemplates[start] || null;
                 }
                 return null;
             });
         },
     });
-    /* eslint-enable flowtype-errors/uncovered */
 
     return result;
 };
 
 const processTemplate = (
-    tpl: BabelNodeTaggedTemplateExpression,
+    tpl: TaggedTemplateExpression,
     result: FileResult,
     // getBinding?: (name: string) => Binding,
     // seenTemplates,
     getTemplate?: (name: string) => Document | null,
 ): Template | null | undefined => {
     // 'cooked' is the string as runtime javascript will see it.
-    const literals = tpl.quasi.quasis.map((q) => q.value.cooked || '');
+    const literals = tpl.quasi.quasis.map((q) => q.value.cooked || "");
     const expressions = tpl.quasi.expressions.map(
         (expr): null | Document | Import => {
             const loc: Loc = {
@@ -341,7 +346,7 @@ const processTemplate = (
                 line: expr.loc?.start.line ?? -1,
                 path: result.path,
             };
-            if (expr.type !== 'Identifier') {
+            if (expr.type !== "Identifier") {
                 result.errors.push({
                     loc,
                     message: `Template literal interpolation must be an identifier`,
@@ -378,29 +383,38 @@ const processTemplate = (
     };
 };
 
-const getLocals = (dir: unknown, toplevel: BabelNodeImportDeclaration, myPath: string): {
-    [key: string]: Import
-} | null | undefined => {
-    if (toplevel.importKind === 'type') {
+const getLocals = (
+    dir: string,
+    toplevel: ImportDeclaration,
+    myPath: string,
+    config: Config,
+):
+    | {
+          [key: string]: Import;
+      }
+    | null
+    | undefined => {
+    if (toplevel.importKind === "type") {
         return null;
     }
-    const importPath = toplevel.source.value.startsWith('.')
-        ? path.resolve(path.join(dir, toplevel.source.value))
-        : toplevel.source.value;
+    const fixedPath = fixPathResolution(toplevel.source.value, config);
+    const importPath = fixedPath.startsWith(".")
+        ? path.resolve(path.join(dir, fixedPath))
+        : fixedPath;
     const locals: Record<string, any> = {};
     toplevel.specifiers.forEach((spec) => {
-        if (spec.type === 'ImportDefaultSpecifier') {
+        if (spec.type === "ImportDefaultSpecifier") {
             locals[spec.local.name] = {
-                type: 'import',
-                name: 'default',
+                type: "import",
+                name: "default",
                 path: importPath,
                 loc: {start: spec.start, end: spec.end, path: myPath},
             };
-        } else if (spec.type === 'ImportSpecifier') {
+        } else if (spec.type === "ImportSpecifier") {
             locals[spec.local.name] = {
-                type: 'import',
+                type: "import",
                 name:
-                    spec.imported.type === 'Identifier'
+                    spec.imported.type === "Identifier"
                         ? spec.imported.name
                         : spec.imported.value,
                 path: importPath,
@@ -413,21 +427,24 @@ const getLocals = (dir: unknown, toplevel: BabelNodeImportDeclaration, myPath: s
 
 export const processFiles = (
     filePaths: Array<string>,
-    getFileSource: (path: string) => string | {
-        text: string
-        resolvedPath: string
-    },
+    config: Config,
+    getFileSource: (path: string) =>
+        | string
+        | {
+              text: string;
+              resolvedPath: string;
+          },
 ): Files => {
     const files: Files = {};
     const toProcess = filePaths.slice();
     while (toProcess.length) {
         const next = toProcess.shift();
-        if (files[next]) {
+        if (!next || files[next]) {
             continue;
         }
-        const result = processFile(next, getFileSource(next));
+        const result = processFile(next, getFileSource(next), config);
         files[next] = result;
-        listExternalReferences(result).forEach((path) => {
+        listExternalReferences(result, config).forEach((path) => {
             if (!files[path] && !toProcess.includes(path)) {
                 toProcess.push(path);
             }

package/src/parser/resolve.ts

@@ -1,30 +1,41 @@
-import gql from 'graphql-tag';
-import {getPathWithExtension} from './utils';
-import type {DocumentNode} from 'graphql/language/ast';
-import type {FileResult, Files, Import, Template, Document} from './parse';
+import gql from "graphql-tag";
+import {getPathWithExtension} from "./utils";
+import type {DocumentNode} from "graphql/language/ast";
+import type {FileResult, Files, Import, Template, Document} from "./parse";
+import {Config} from "../types";
 
 export type Resolved = {
     [key: string]: {
-        document: DocumentNode
-        raw: Template
-    }
+        document: DocumentNode;
+        raw: Template;
+    };
 };
 
-export const resolveDocuments = (files: Files): {
-    resolved: Resolved
-    errors: FileResult['errors']
+export const resolveDocuments = (
+    files: Files,
+    config: Config,
+): {
+    resolved: Resolved;
+    errors: FileResult["errors"];
 } => {
     const resolved: Resolved = {};
-    const errors: FileResult['errors'] = [];
+    const errors: FileResult["errors"] = [];
     Object.keys(files).forEach((path) => {
         const file = files[path];
         file.operations.forEach((op) => {
-            resolveGqlTemplate(op.source, files, errors, resolved, {});
+            resolveGqlTemplate(op.source, files, errors, resolved, {}, config);
         });
         Object.keys(file.locals).forEach((k) => {
             const local = file.locals[k];
-            if (local.type === 'document') {
-                resolveGqlTemplate(local.source, files, errors, resolved, {});
+            if (local.type === "document") {
+                resolveGqlTemplate(
+                    local.source,
+                    files,
+                    errors,
+                    resolved,
+                    {},
+                    config,
+                );
             }
         });
     });
@@ -34,17 +45,21 @@ export const resolveDocuments = (files: Files): {
 const resolveImport = (
     expr: Import,
     files: Files,
-    errors: FileResult['errors'],
+    errors: FileResult["errors"],
     seen: {
-        [key: string]: true
+        [key: string]: true;
     },
+    config: Config,
 ): Document | null | undefined => {
-    const absPath: string = getPathWithExtension(expr.path);
+    const absPath = getPathWithExtension(expr.path, config);
+    if (!absPath) {
+        return null;
+    }
     if (seen[absPath]) {
         errors.push({
             loc: expr.loc,
             message: `Circular import ${Object.keys(seen).join(
-                ' -> ',
+                " -> ",
             )} -> ${absPath}`,
         });
         return null;
@@ -63,8 +78,8 @@ const resolveImport = (
         return null;
     }
     const value = res.exports[expr.name];
-    if (value.type === 'import') {
-        return resolveImport(value, files, errors, seen);
+    if (value.type === "import") {
+        return resolveImport(value, files, errors, seen, config);
     }
     return value;
 };
@@ -72,13 +87,14 @@ const resolveImport = (
 const resolveGqlTemplate = (
     template: Template,
     files: Files,
-    errors: FileResult['errors'],
+    errors: FileResult["errors"],
     resolved: Resolved,
     seen: {
-        [key: string]: Template
+        [key: string]: Template;
     },
+    config: Config,
 ): DocumentNode | null | undefined => {
-    const key = template.loc.path + ':' + template.loc.line;
+    const key = template.loc.path + ":" + template.loc.line;
     if (seen[key]) {
         errors.push({
             loc: template.loc,
@@ -86,12 +102,12 @@ const resolveGqlTemplate = (
                 .map(
                     (k) =>
                         k +
-                        ' ~ ' +
+                        " ~ " +
                         seen[k].expressions.length +
-                        ',' +
+                        "," +
                         seen[k].literals.length,
                 )
-                .join(' -> ')} -> ${key}`,
+                .join(" -> ")} -> ${key}`,
         });
         return null;
     }
@@ -100,17 +116,31 @@ const resolveGqlTemplate = (
         return resolved[key].document;
     }
     const expressions = template.expressions.map((expr) => {
-        if (expr.type === 'import') {
-            const document = resolveImport(expr, files, errors, {});
+        if (expr.type === "import") {
+            const document = resolveImport(expr, files, errors, {}, config);
             return document
-                ? resolveGqlTemplate(document.source, files, errors, resolved, {
-                      ...seen,
-                  })
+                ? resolveGqlTemplate(
+                      document.source,
+                      files,
+                      errors,
+                      resolved,
+                      {
+                          ...seen,
+                      },
+                      config,
+                  )
                 : null;
         }
-        return resolveGqlTemplate(expr.source, files, errors, resolved, {
-            ...seen,
-        });
+        return resolveGqlTemplate(
+            expr.source,
+            files,
+            errors,
+            resolved,
+            {
+                ...seen,
+            },
+            config,
+        );
     });
     if (expressions.includes(null)) {
         return null;

package/src/parser/utils.ts

@@ -1,6 +1,20 @@
-import fs from 'fs';
+import fs from "fs";
+import {Config} from "../types";
 
-export const getPathWithExtension = (pathWithoutExtension: string): string => {
+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);
     if (
         /\.(less|css|png|gif|jpg|jpeg|js|jsx|ts|tsx|mjs)$/.test(
             pathWithoutExtension,
@@ -8,21 +22,17 @@ export const getPathWithExtension = (pathWithoutExtension: string): string => {
     ) {
         return pathWithoutExtension;
     }
-    if (fs.existsSync(pathWithoutExtension + '.js')) {
-        return pathWithoutExtension + '.js';
+    if (fs.existsSync(pathWithoutExtension + ".js")) {
+        return pathWithoutExtension + ".js";
     }
-    if (fs.existsSync(pathWithoutExtension + '.jsx')) {
-        return pathWithoutExtension + '.jsx';
+    if (fs.existsSync(pathWithoutExtension + ".jsx")) {
+        return pathWithoutExtension + ".jsx";
     }
-    if (fs.existsSync(pathWithoutExtension + '.tsx')) {
-        return pathWithoutExtension + '.tsx';
+    if (fs.existsSync(pathWithoutExtension + ".tsx")) {
+        return pathWithoutExtension + ".tsx";
     }
-    if (fs.existsSync(pathWithoutExtension + '.ts')) {
-        return pathWithoutExtension + '.ts';
+    if (fs.existsSync(pathWithoutExtension + ".ts")) {
+        return pathWithoutExtension + ".ts";
     }
-    // NOTE(john): This is a bit of a hack, but it's necessary for when we
-    // have a file that doesn't exist. This will happen when we delete all of
-    // the type files before re-running graphql-flow again. We want to ensure
-    // that we don't error out in this case.
-    return "";
+    return null;
 };