@khanacademy/graphql-flow 3.1.0 → 3.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @khanacademy/graphql-flow
 
+## 3.1.2
+
+### Patch Changes
+
+-   09f72b5: Fix handling of input objects with required attributes that have a default value
+
+## 3.1.1
+
+### Patch Changes
+
+-   45f09ef: Fix up some more alias resolution in graphql-flow.
+
 ## 3.1.0
 
 ### Minor Changes

package/dist/cli/run.js

@@ -9,6 +9,8 @@ var _parse = require("../parser/parse");
 
 var _resolve = require("../parser/resolve");
 
+var _utils = require("../parser/utils");
+
 var _config = require("./config");
 
 var _apolloUtilities = require("apollo-utilities");
@@ -69,32 +71,16 @@ const inputFiles = cliFiles.length ? cliFiles : findGraphqlTagReferences(makeAbs
 /** Step (2) */
 
 const files = (0, _parse.processFiles)(inputFiles, config, f => {
-  if ((0, _fs.existsSync)(f)) {
-    return (0, _fs.readFileSync)(f, "utf8");
-  }
-
-  if ((0, _fs.existsSync)(f + ".js")) {
-    return {
-      text: (0, _fs.readFileSync)(f + ".js", "utf8"),
-      resolvedPath: f + ".js"
-    };
-  }
-
-  if ((0, _fs.existsSync)(f + ".ts")) {
-    return {
-      text: (0, _fs.readFileSync)(f + ".ts", "utf8"),
-      resolvedPath: f + ".ts"
-    };
-  }
+  const resolvedPath = (0, _utils.getPathWithExtension)(f, config);
 
-  if ((0, _fs.existsSync)(f + ".tsx")) {
-    return {
-      text: (0, _fs.readFileSync)(f + ".tsx", "utf8"),
-      resolvedPath: f + ".tsx"
-    };
+  if (!resolvedPath) {
+    throw new Error(`Unable to find ${f}`);
   }
 
-  throw new Error(`Unable to find ${f}`);
+  return {
+    text: (0, _fs.readFileSync)(resolvedPath, "utf8"),
+    resolvedPath
+  };
 });
 let filesHadErrors = false;
 Object.keys(files).forEach(key => {

package/dist/generateVariablesType.js

@@ -27,7 +27,7 @@ const inputObjectToFlow = (ctx, name) => {
     return babelTypes.tsLiteralType(babelTypes.stringLiteral(`Unknown input object ${name}`));
   }
 
-  return (0, _utils.maybeAddDescriptionComment)(inputObject.description, (0, _utils.objectTypeFromProperties)(inputObject.inputFields.map(vbl => (0, _utils.maybeAddDescriptionComment)(vbl.description, maybeOptionalObjectTypeProperty(vbl.name, inputRefToFlow(ctx, vbl.type))))));
+  return (0, _utils.maybeAddDescriptionComment)(inputObject.description, (0, _utils.objectTypeFromProperties)(inputObject.inputFields.map(vbl => (0, _utils.maybeAddDescriptionComment)(vbl.description, maybeOptionalObjectTypeProperty(vbl.name, inputRefToFlow(ctx, vbl.type, vbl.defaultValue != null))))));
 };
 
 exports.inputObjectToFlow = inputObjectToFlow;
@@ -44,9 +44,11 @@ const maybeOptionalObjectTypeProperty = (name, type) => {
 
 exports.maybeOptionalObjectTypeProperty = maybeOptionalObjectTypeProperty;
 
-const inputRefToFlow = (ctx, inputRef) => {
+const inputRefToFlow = (ctx, inputRef, hasDefaultValue = false) => {
   if (inputRef.kind === "NON_NULL") {
-    return _inputRefToFlow(ctx, inputRef.ofType);
+    const result = _inputRefToFlow(ctx, inputRef.ofType);
+
+    return hasDefaultValue ? (0, _utils.nullableType)(result) : result;
   }
 
   const result = _inputRefToFlow(ctx, inputRef);

package/dist/parser/parse.js

@@ -52,7 +52,7 @@ const listExternalReferences = (file, config) => {
   return Object.keys(paths);
 };
 
-const processFile = (filePath, contents) => {
+const processFile = (filePath, contents, config) => {
   const dir = _path.default.dirname(filePath);
 
   const result = {
@@ -75,7 +75,7 @@ const processFile = (filePath, contents) => {
     var _toplevel$declaration;
 
     if (toplevel.type === "ImportDeclaration") {
-      const newLocals = getLocals(dir, toplevel, filePath);
+      const newLocals = getLocals(dir, toplevel, filePath, config);
 
       if (newLocals) {
         Object.keys(newLocals).forEach(k => {
@@ -297,12 +297,13 @@ const processTemplate = (tpl, result, getTemplate) => {
   };
 };
 
-const getLocals = (dir, toplevel, myPath) => {
+const getLocals = (dir, toplevel, myPath, config) => {
   if (toplevel.importKind === "type") {
     return null;
   }
 
-  const importPath = toplevel.source.value.startsWith(".") ? _path.default.resolve(_path.default.join(dir, toplevel.source.value)) : toplevel.source.value;
+  const fixedPath = (0, _utils.fixPathResolution)(toplevel.source.value, config);
+  const importPath = fixedPath.startsWith(".") ? _path.default.resolve(_path.default.join(dir, fixedPath)) : fixedPath;
   const locals = {};
   toplevel.specifiers.forEach(spec => {
     if (spec.type === "ImportDefaultSpecifier") {
@@ -343,7 +344,7 @@ const processFiles = (filePaths, config, getFileSource) => {
       continue;
     }
 
-    const result = processFile(next, getFileSource(next));
+    const result = processFile(next, getFileSource(next), config);
     files[next] = result;
     listExternalReferences(result, config).forEach(path => {
       if (!files[path] && !toProcess.includes(path)) {

package/dist/parser/resolve.js

@@ -38,6 +38,10 @@ exports.resolveDocuments = resolveDocuments;
 const resolveImport = (expr, files, errors, seen, config) => {
   const absPath = (0, _utils.getPathWithExtension)(expr.path, config);
 
+  if (!absPath) {
+    return null;
+  }
+
   if (seen[absPath]) {
     errors.push({
       loc: expr.loc,

package/dist/parser/utils.js

@@ -3,23 +3,30 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getPathWithExtension = void 0;
+exports.getPathWithExtension = exports.fixPathResolution = void 0;
 
 var _fs = _interopRequireDefault(require("fs"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const getPathWithExtension = (pathWithoutExtension, config) => {
-  // Process the path so that we can handle aliases.
+const fixPathResolution = (path, config) => {
   if (config.alias) {
     for (const {
       find,
       replacement
     } of config.alias) {
-      pathWithoutExtension = pathWithoutExtension.replace(find, replacement);
+      path = path.replace(find, replacement);
     }
   }
 
+  return path;
+};
+
+exports.fixPathResolution = fixPathResolution;
+
+const getPathWithExtension = (pathWithoutExtension, config) => {
+  pathWithoutExtension = fixPathResolution(pathWithoutExtension, config);
+
   if (/\.(less|css|png|gif|jpg|jpeg|js|jsx|ts|tsx|mjs)$/.test(pathWithoutExtension)) {
     return pathWithoutExtension;
   }
@@ -38,13 +45,9 @@ const getPathWithExtension = (pathWithoutExtension, config) => {
 
   if (_fs.default.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;
 };
 
 exports.getPathWithExtension = getPathWithExtension;

package/package.json

@@ -1,9 +1,14 @@
 {
     "name": "@khanacademy/graphql-flow",
-    "version": "3.1.0",
+    "version": "3.1.2",
     "bin": {
         "graphql-flow": "./dist/cli/run.js"
     },
+    "jest": {
+        "testPathIgnorePatterns": [
+            "dist"
+        ]
+    },
     "scripts": {
         "test": "jest",
         "publish:ci": "yarn run build && changeset publish",

package/schema.json

@@ -91,7 +91,23 @@
         "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/__test__/example-schema.graphql

@@ -60,6 +60,7 @@ input CharacterInput {
   friends: [ID!]
   appearsIn: [Episode!]
   candies: PositiveNumber!
+  friendly: Boolean! = true
 }
 
 type Mutation {

package/src/__test__/graphql-flow.test.ts

@@ -621,6 +621,7 @@ describe("graphql-flow generation", () => {
                     - JEDI*/
                     "NEW_HOPE" | "EMPIRE" | "JEDI"> | null | undefined;
                     candies: number;
+                    friendly?: boolean | null | undefined;
                   };
                 },
                     response: {

package/src/cli/run.ts

@@ -6,6 +6,7 @@ import type {GraphQLSchema} from "graphql/type/schema";
 import {generateTypeFiles, processPragmas} from "../generateTypeFiles";
 import {processFiles} from "../parser/parse";
 import {resolveDocuments} from "../parser/resolve";
+import {getPathWithExtension} from "../parser/utils";
 import {findApplicableConfig, getSchemas, loadConfigFile} from "./config";
 
 import {addTypenameToDocument} from "apollo-utilities";
@@ -81,22 +82,11 @@ const inputFiles = cliFiles.length
 /** Step (2) */
 
 const files = processFiles(inputFiles, config, (f) => {
-    if (existsSync(f)) {
-        return readFileSync(f, "utf8");
+    const resolvedPath = getPathWithExtension(f, config);
+    if (!resolvedPath) {
+        throw new Error(`Unable to find ${f}`);
     }
-    if (existsSync(f + ".js")) {
-        return {text: readFileSync(f + ".js", "utf8"), resolvedPath: f + ".js"};
-    }
-    if (existsSync(f + ".ts")) {
-        return {text: readFileSync(f + ".ts", "utf8"), resolvedPath: f + ".ts"};
-    }
-    if (existsSync(f + ".tsx")) {
-        return {
-            text: readFileSync(f + ".tsx", "utf8"),
-            resolvedPath: f + ".tsx",
-        };
-    }
-    throw new Error(`Unable to find ${f}`);
+    return {text: readFileSync(resolvedPath, "utf8"), resolvedPath};
 });
 
 let filesHadErrors = false;

package/src/generateVariablesType.ts

@@ -31,7 +31,7 @@ export const inputObjectToFlow = (
                     vbl.description,
                     maybeOptionalObjectTypeProperty(
                         vbl.name,
-                        inputRefToFlow(ctx, vbl.type),
+                        inputRefToFlow(ctx, vbl.type, vbl.defaultValue != null),
                     ),
                 ),
             ),
@@ -58,9 +58,11 @@ export const maybeOptionalObjectTypeProperty = (
 export const inputRefToFlow = (
     ctx: Context,
     inputRef: IntrospectionInputTypeRef,
+    hasDefaultValue = false,
 ): babelTypes.TSType => {
     if (inputRef.kind === "NON_NULL") {
-        return _inputRefToFlow(ctx, inputRef.ofType);
+        const result = _inputRefToFlow(ctx, inputRef.ofType);
+        return hasDefaultValue ? nullableType(result) : result;
     }
     const result = _inputRefToFlow(ctx, inputRef);
     return transferLeadingComments(result, nullableType(result));

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

@@ -50,7 +50,7 @@ describe("getPathWithExtension", () => {
         expect(result).toBe("/path/to/file.js");
     });
 
-    it("returns an empty string if no file is found", () => {
+    it("returns null if no file is found", () => {
         // Arrange
         jest.spyOn(fs, "existsSync").mockImplementation((path) => false);
 
@@ -58,7 +58,7 @@ describe("getPathWithExtension", () => {
         const result = getPathWithExtension("/path/to/file", config);
 
         // Assert
-        expect(result).toBe("");
+        expect(result).toBe(null);
     });
 
     it("maps aliases to their correct value", () => {

package/src/parser/parse.ts

@@ -11,7 +11,7 @@ import traverse from "@babel/traverse";
 
 import path from "path";
 
-import {getPathWithExtension} from "./utils";
+import {fixPathResolution, getPathWithExtension} from "./utils";
 import {Config} from "../types";
 
 /**
@@ -152,6 +152,7 @@ export const processFile = (
               text: string;
               resolvedPath: string;
           },
+    config: Config,
 ): FileResult => {
     const dir = path.dirname(filePath);
     const result: FileResult = {
@@ -177,7 +178,7 @@ export const processFile = (
 
     ast.program.body.forEach((toplevel) => {
         if (toplevel.type === "ImportDeclaration") {
-            const newLocals = getLocals(dir, toplevel, filePath);
+            const newLocals = getLocals(dir, toplevel, filePath, config);
             if (newLocals) {
                 Object.keys(newLocals).forEach((k) => {
                     const local = newLocals[k];
@@ -386,6 +387,7 @@ const getLocals = (
     dir: string,
     toplevel: ImportDeclaration,
     myPath: string,
+    config: Config,
 ):
     | {
           [key: string]: Import;
@@ -395,9 +397,10 @@ const getLocals = (
     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") {
@@ -439,7 +442,7 @@ export const processFiles = (
         if (!next || files[next]) {
             continue;
         }
-        const result = processFile(next, getFileSource(next));
+        const result = processFile(next, getFileSource(next), config);
         files[next] = result;
         listExternalReferences(result, config).forEach((path) => {
             if (!files[path] && !toProcess.includes(path)) {

package/src/parser/resolve.ts

@@ -51,7 +51,10 @@ const resolveImport = (
     },
     config: Config,
 ): Document | null | undefined => {
-    const absPath: string = getPathWithExtension(expr.path, config);
+    const absPath = getPathWithExtension(expr.path, config);
+    if (!absPath) {
+        return null;
+    }
     if (seen[absPath]) {
         errors.push({
             loc: expr.loc,

package/src/parser/utils.ts

@@ -1,19 +1,20 @@
 import fs from "fs";
 import {Config} from "../types";
 
-export const getPathWithExtension = (
-    pathWithoutExtension: string,
-    config: Config,
-): string => {
-    // Process the path so that we can handle aliases.
+export const fixPathResolution = (path: string, config: Config) => {
     if (config.alias) {
         for (const {find, replacement} of config.alias) {
-            pathWithoutExtension = pathWithoutExtension.replace(
-                find,
-                replacement,
-            );
+            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,
@@ -33,9 +34,5 @@ export const getPathWithExtension = (
     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;
 };