@khanacademy/graphql-flow 3.1.3 → 3.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @khanacademy/graphql-flow
 
+## 3.2.0
+
+### Minor Changes
+
+-   96c201e: Add a noComments config option to exclude all comments in the output
+-   7c01b6a: Add a --schema-file graphql argument, and allow exporting a function from the config.js file
+-   96c201e: Add a `noComments` config option to exclude all comments
+
 ## 3.1.3
 
 ### Patch Changes

package/dist/cli/config.js

@@ -3,12 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.validateOrThrow = exports.loadConfigFile = exports.getSchemas = exports.findApplicableConfig = void 0;
-var _schemaFromIntrospectionData = require("../schemaFromIntrospectionData");
+exports.validateOrThrow = exports.parseCliOptions = exports.makeAbsPath = exports.loadConfigFile = exports.getSchemas = exports.getInputFiles = exports.findApplicableConfig = void 0;
 var _schema = _interopRequireDefault(require("../../schema.json"));
+var _schemaFromIntrospectionData = require("../schemaFromIntrospectionData");
 var _fs = _interopRequireDefault(require("fs"));
 var _graphql = require("graphql");
 var _jsonschema = require("jsonschema");
+var _minimist = _interopRequireDefault(require("minimist"));
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const validateOrThrow = (value, jsonSchema) => {
   const result = (0, _jsonschema.validate)(value, jsonSchema);
@@ -17,16 +20,47 @@ const validateOrThrow = (value, jsonSchema) => {
   }
 };
 exports.validateOrThrow = validateOrThrow;
-const loadConfigFile = configFile => {
-  const data = require(configFile);
+const makeAbsPath = (maybeRelativePath, basePath) => {
+  return _path.default.isAbsolute(maybeRelativePath) ? maybeRelativePath : _path.default.join(basePath, maybeRelativePath);
+};
+exports.makeAbsPath = makeAbsPath;
+const loadConfigFile = options => {
+  let data = require(options.configFilePath);
+  if (typeof data === "function") {
+    data = data(options);
+  } else {
+    if (options.schemaFile) {
+      if (Array.isArray(data.generate)) {
+        data.generate.forEach(item => {
+          item.schemaFilePath = options.schemaFile;
+        });
+      } else {
+        data.generate.schemaFilePath = options.schemaFile;
+      }
+    }
+  }
   validateOrThrow(data, _schema.default);
   return data;
 };
+exports.loadConfigFile = loadConfigFile;
+const findGraphqlTagReferences = root => {
+  // NOTE(john): We want to include untracked files here so that we can
+  // generate types for them. This is useful for when we have a new file
+  // that we want to generate types for, but we haven't committed it yet.
+  const response = (0, _child_process.execSync)("git grep -I --word-regexp --name-only --fixed-strings --untracked 'graphql-tag' -- '*.js' '*.jsx' '*.ts' '*.tsx'", {
+    encoding: "utf8",
+    cwd: root
+  });
+  return response.trim().split("\n").map(relative => _path.default.join(root, relative));
+};
+const getInputFiles = (options, config) => {
+  return options.cliFiles.length ? options.cliFiles : findGraphqlTagReferences(makeAbsPath(config.crawl.root, _path.default.dirname(options.configFilePath)));
+};
 
 /**
  * Loads a .json 'introspection query response', or a .graphql schema definition.
  */
-exports.loadConfigFile = loadConfigFile;
+exports.getInputFiles = getInputFiles;
 const getSchemas = schemaFilePath => {
   const raw = _fs.default.readFileSync(schemaFilePath, "utf8");
   if (schemaFilePath.endsWith(".graphql")) {
@@ -46,13 +80,30 @@ const getSchemas = schemaFilePath => {
     return [schemaForValidation, schemaForTypeGeneration];
   }
 };
+exports.getSchemas = getSchemas;
+const parseCliOptions = (argv, relativeBase) => {
+  const args = (0, _minimist.default)(argv);
+  let [configFilePath, ...cliFiles] = args._;
+  if (args.h || args.help || !configFilePath) {
+    return false;
+  }
+  configFilePath = makeAbsPath(configFilePath, relativeBase);
+  const options = {
+    configFilePath,
+    cliFiles
+  };
+  if (args["schema-file"]) {
+    options.schemaFile = args["schema-file"];
+  }
+  return options;
+};
 
 /**
  * Find the first item of the `config.generate` array where both:
  * - no item of `exclude` matches
  * - at least one item of `match` matches
  */
-exports.getSchemas = getSchemas;
+exports.parseCliOptions = parseCliOptions;
 const findApplicableConfig = (path, configs) => {
   if (!Array.isArray(configs)) {
     configs = [configs];

package/dist/cli/run.js

@@ -8,7 +8,6 @@ var _resolve = require("../parser/resolve");
 var _utils = require("../parser/utils");
 var _config = require("./config");
 var _apolloUtilities = require("apollo-utilities");
-var _child_process = require("child_process");
 var _fs = require("fs");
 var _printer = require("graphql/language/printer");
 var _validation = require("graphql/validation");
@@ -26,29 +25,17 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  * 4) generate types for all resolved Queries & Mutations
  */
 /** Step (1) */
-const findGraphqlTagReferences = root => {
-  // NOTE(john): We want to include untracked files here so that we can
-  // generate types for them. This is useful for when we have a new file
-  // that we want to generate types for, but we haven't committed it yet.
-  const response = (0, _child_process.execSync)("git grep -I --word-regexp --name-only --fixed-strings --untracked 'graphql-tag' -- '*.js' '*.jsx' '*.ts' '*.tsx'", {
-    encoding: "utf8",
-    cwd: root
-  });
-  return response.trim().split("\n").map(relative => _path.default.join(root, relative));
-};
-const [_, __, configFilePath, ...cliFiles] = process.argv;
-if (configFilePath === "-h" || configFilePath === "--help" || configFilePath === "help" || !configFilePath) {
+const options = (0, _config.parseCliOptions)(process.argv.slice(2), process.cwd());
+if (options === false) {
   console.log(`graphql-flow
 
-Usage: graphql-flow [configFile.json] [filesToCrawl...]`);
+Usage: graphql-flow [configFile.json] [filesToCrawl...]
+Options:
+  --schema-file: provide a schema file to override the one defined in config`);
   process.exit(1);
 }
-const makeAbsPath = (maybeRelativePath, basePath) => {
-  return _path.default.isAbsolute(maybeRelativePath) ? maybeRelativePath : _path.default.join(basePath, maybeRelativePath);
-};
-const absConfigPath = makeAbsPath(configFilePath, process.cwd());
-const config = (0, _config.loadConfigFile)(absConfigPath);
-const inputFiles = cliFiles.length ? cliFiles : findGraphqlTagReferences(makeAbsPath(config.crawl.root, _path.default.dirname(absConfigPath)));
+const config = (0, _config.loadConfigFile)(options);
+const inputFiles = (0, _config.getInputFiles)(options, config);
 
 /** Step (2) */
 
@@ -101,7 +88,7 @@ console.log(Object.keys(resolved).length, "resolved queries");
 const schemaCache = {};
 const getCachedSchemas = schemaFilePath => {
   if (!schemaCache[schemaFilePath]) {
-    schemaCache[schemaFilePath] = (0, _config.getSchemas)(makeAbsPath(schemaFilePath, _path.default.dirname(absConfigPath)));
+    schemaCache[schemaFilePath] = (0, _config.getSchemas)((0, _config.makeAbsPath)(schemaFilePath, _path.default.dirname(options.configFilePath)));
   }
   return schemaCache[schemaFilePath];
 };

package/dist/enums.js

@@ -19,7 +19,7 @@ const experimentalEnumTypeToFlow = (ctx, enumConfig, description) => {
   if (ctx.experimentalEnumsMap) {
     ctx.experimentalEnumsMap[enumConfig.name] = enumDeclaration;
   }
-  return (0, _utils.maybeAddDescriptionComment)(description, babelTypes.tsTypeReference(enumDeclaration.id));
+  return (0, _utils.maybeAddDescriptionComment)(ctx.noComments ? null : description, babelTypes.tsTypeReference(enumDeclaration.id));
 };
 exports.experimentalEnumTypeToFlow = experimentalEnumTypeToFlow;
 const enumTypeToFlow = (ctx, name) => {
@@ -28,7 +28,7 @@ const enumTypeToFlow = (ctx, name) => {
   if (enumConfig.description) {
     combinedDescription = enumConfig.description + "\n\n" + combinedDescription;
   }
-  return ctx.experimentalEnumsMap ? experimentalEnumTypeToFlow(ctx, enumConfig, combinedDescription) : (0, _utils.maybeAddDescriptionComment)(combinedDescription, babelTypes.tsUnionType(enumConfig.enumValues.map(n => babelTypes.tsLiteralType(babelTypes.stringLiteral(n.name)))));
+  return ctx.experimentalEnumsMap ? experimentalEnumTypeToFlow(ctx, enumConfig, combinedDescription) : (0, _utils.maybeAddDescriptionComment)(ctx.noComments ? null : combinedDescription, babelTypes.tsUnionType(enumConfig.enumValues.map(n => babelTypes.tsLiteralType(babelTypes.stringLiteral(n.name)))));
 };
 exports.enumTypeToFlow = enumTypeToFlow;
 const builtinScalars = exports.builtinScalars = {

package/dist/generateResponseType.js

@@ -15,7 +15,9 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 
 const generateResponseType = (schema, query, ctx) => {
   const ast = querySelectionToObjectType(ctx, query.selectionSet.selections, query.operation === "mutation" ? schema.typesByName.Mutation : schema.typesByName.Query, query.operation === "mutation" ? "mutation" : "query");
-  return (0, _generator.default)(ast).code;
+  return (0, _generator.default)(ast, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
 exports.generateResponseType = generateResponseType;
 const sortedObjectTypeAnnotation = (ctx, properties) => {
@@ -48,7 +50,9 @@ const generateFragmentType = (schema, fragment, ctx) => {
   } else {
     throw new Error(`Unknown ${onType}`);
   }
-  return (0, _generator.default)(ast).code;
+  return (0, _generator.default)(ast, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
 exports.generateFragmentType = generateFragmentType;
 const _typeToFlow = (ctx, type, selection) => {

package/dist/generateVariablesType.js

@@ -82,6 +82,8 @@ const generateVariablesType = (schema, item, ctx) => {
   const variableObject = (0, _utils.objectTypeFromProperties)((item.variableDefinitions || []).map(vbl => {
     return maybeOptionalObjectTypeProperty(vbl.variable.name.value, variableToFlow(ctx, vbl.type));
   }));
-  return (0, _generator.default)(variableObject).code;
+  return (0, _generator.default)(variableObject, {
+    comments: ctx.noComments ? false : true
+  }).code;
 };
 exports.generateVariablesType = generateVariablesType;

package/dist/index.js

@@ -25,7 +25,8 @@ const optionsToConfig = (schema, definitions, options, errors = []) => {
     readOnlyArray: (_options$readOnlyArra = options === null || options === void 0 ? void 0 : options.readOnlyArray) !== null && _options$readOnlyArra !== void 0 ? _options$readOnlyArra : true,
     scalars: (_options$scalars = options === null || options === void 0 ? void 0 : options.scalars) !== null && _options$scalars !== void 0 ? _options$scalars : {},
     typeScript: (_options$typeScript = options === null || options === void 0 ? void 0 : options.typeScript) !== null && _options$typeScript !== void 0 ? _options$typeScript : false,
-    omitFileExtensions: (_options$omitFileExte = options === null || options === void 0 ? void 0 : options.omitFileExtensions) !== null && _options$omitFileExte !== void 0 ? _options$omitFileExte : false
+    omitFileExtensions: (_options$omitFileExte = options === null || options === void 0 ? void 0 : options.omitFileExtensions) !== null && _options$omitFileExte !== void 0 ? _options$omitFileExte : false,
+    noComments: options === null || options === void 0 ? void 0 : options.noComments
   };
   const fragments = {};
   definitions.forEach(def => {
@@ -66,8 +67,8 @@ const documentToFlowTypes = (document, schema, options) => {
         path: [name],
         allObjectTypes: options !== null && options !== void 0 && options.exportAllObjectTypes ? types : null
       })};`;
-      const extraTypes = codegenExtraTypes(types);
-      const experimentalEnums = codegenExtraTypes(config.experimentalEnumsMap || {});
+      const extraTypes = codegenExtraTypes(types, config);
+      const experimentalEnums = codegenExtraTypes(config.experimentalEnumsMap || {}, config);
       return {
         name,
         typeName: name,
@@ -93,8 +94,8 @@ const documentToFlowTypes = (document, schema, options) => {
       // TODO(jared): Maybe make this template configurable?
       // We'll see what's required to get webapp on board.
       const code = `export type ${typeName} = {\n    variables: ${variables},\n    response: ${response}\n};`;
-      const extraTypes = codegenExtraTypes(types);
-      const experimentalEnums = codegenExtraTypes(config.experimentalEnumsMap || {});
+      const extraTypes = codegenExtraTypes(types, config);
+      const experimentalEnums = codegenExtraTypes(config.experimentalEnumsMap || {}, config);
       return {
         name,
         typeName,
@@ -110,10 +111,12 @@ const documentToFlowTypes = (document, schema, options) => {
   return result;
 };
 exports.documentToFlowTypes = documentToFlowTypes;
-function codegenExtraTypes(types) {
+function codegenExtraTypes(types, ctx) {
   const extraTypes = {};
   Object.keys(types).forEach(k => {
-    extraTypes[k] = (0, _generator.default)(types[k]).code;
+    extraTypes[k] = (0, _generator.default)(types[k], {
+      comments: ctx.noComments ? false : true
+    }).code;
   });
   return extraTypes;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@khanacademy/graphql-flow",
-    "version": "3.1.3",
+    "version": "3.2.0",
     "bin": {
         "graphql-flow": "./dist/cli/run.js"
     },
@@ -48,6 +48,7 @@
         "@khanacademy/wonder-stuff-core": "^1.5.1",
         "apollo-utilities": "^1.3.4",
         "graphql": "^16.9.0",
-        "jsonschema": "^1.4.1"
+        "jsonschema": "^1.4.1",
+        "minimist": "^1.2.8"
     }
 }

package/schema.json

@@ -40,6 +40,9 @@
                 "regenerateCommand": {
                     "type": "string"
                 },
+                "noComments": {
+                    "type": "boolean"
+                },
                 "readOnlyArray": {
                     "type": "boolean"
                 },

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

@@ -589,5 +589,36 @@ describe("graphql-flow generation", () => {
                 };
             `);
         });
+
+        it("should strip comments", () => {
+            const result = rawQueryToFlowTypes(
+                `mutation addCharacter($character: CharacterInput!) {
+                    addCharacter(character: $character) {
+                        id
+                    }
+                }`,
+                {readOnlyArray: false, noComments: true},
+            );
+
+            expect(result).toMatchInlineSnapshot(`
+                // addCharacterType.js
+                export type addCharacterType = {
+                    variables: {
+                  character: {
+                    name: string;
+                    friends?: ReadonlyArray<string> | null | undefined;
+                    appearsIn?: ReadonlyArray<"NEW_HOPE" | "EMPIRE" | "JEDI"> | null | undefined;
+                    candies: number;
+                    friendly?: boolean | null | undefined;
+                  };
+                },
+                    response: {
+                  addCharacter: {
+                    id: string;
+                  } | null | undefined;
+                }
+                };
+            `);
+        });
     });
 });

package/src/cli/__test__/config.test.ts

@@ -1,9 +1,48 @@
 import {describe, it, expect} from "@jest/globals";
 
 import type {Config} from "../../types";
-import {findApplicableConfig, validateOrThrow} from "../config";
+import {
+    findApplicableConfig,
+    parseCliOptions,
+    validateOrThrow,
+} from "../config";
 import configSchema from "../../../schema.json";
 
+describe("parseCliOptions", () => {
+    it("should handle basic invocation", () => {
+        expect(parseCliOptions(["config.json"], "./")).toEqual({
+            configFilePath: "config.json",
+            cliFiles: [],
+        });
+    });
+
+    it("should handle cli files", () => {
+        expect(
+            parseCliOptions(["config.json", "one.js", "two.ts"], "./"),
+        ).toEqual({
+            configFilePath: "config.json",
+            cliFiles: ["one.js", "two.ts"],
+        });
+    });
+
+    it("should handle -h", () => {
+        expect(
+            parseCliOptions(["config.json", "-h", "one.js", "two.ts"], "./"),
+        ).toEqual(false);
+        expect(parseCliOptions([], "./")).toEqual(false);
+    });
+
+    it("should pick up schema-file", () => {
+        expect(
+            parseCliOptions(["config.json", "--schema-file=some.schema"], "./"),
+        ).toEqual({
+            configFilePath: "config.json",
+            cliFiles: [],
+            schemaFile: "some.schema",
+        });
+    });
+});
+
 describe("findApplicableConfig", () => {
     it("should work with one that matches", () => {
         const config = {

package/src/cli/config.ts

@@ -1,8 +1,8 @@
-import type {Schema} from "../types";
 import type {GraphQLSchema} from "graphql/type/schema";
+import type {CliOptions, Schema} from "../types";
 
-import {schemaFromIntrospectionData} from "../schemaFromIntrospectionData";
 import configSchema from "../../schema.json";
+import {schemaFromIntrospectionData} from "../schemaFromIntrospectionData";
 
 import fs from "fs";
 import {
@@ -12,8 +12,11 @@ import {
     graphqlSync,
     IntrospectionQuery,
 } from "graphql";
-import type {Config, GenerateConfig} from "../types";
 import {validate} from "jsonschema";
+import processArgs from "minimist";
+import type {Config, GenerateConfig} from "../types";
+import {execSync} from "child_process";
+import path from "path";
 
 export const validateOrThrow = (value: unknown, jsonSchema: unknown) => {
     const result = validate(value, jsonSchema);
@@ -24,12 +27,61 @@ export const validateOrThrow = (value: unknown, jsonSchema: unknown) => {
     }
 };
 
-export const loadConfigFile = (configFile: string): Config => {
-    const data: Config = require(configFile);
+export const makeAbsPath = (maybeRelativePath: string, basePath: string) => {
+    return path.isAbsolute(maybeRelativePath)
+        ? maybeRelativePath
+        : path.join(basePath, maybeRelativePath);
+};
+
+export const loadConfigFile = (options: CliOptions): Config => {
+    let data:
+        | Config
+        | ((c: CliOptions) => Config) = require(options.configFilePath);
+    if (typeof data === "function") {
+        data = data(options);
+    } else {
+        if (options.schemaFile) {
+            if (Array.isArray(data.generate)) {
+                data.generate.forEach((item) => {
+                    item.schemaFilePath = options.schemaFile!;
+                });
+            } else {
+                data.generate.schemaFilePath = options.schemaFile;
+            }
+        }
+    }
     validateOrThrow(data, configSchema);
     return data;
 };
 
+const findGraphqlTagReferences = (root: string): Array<string> => {
+    // NOTE(john): We want to include untracked files here so that we can
+    // generate types for them. This is useful for when we have a new file
+    // that we want to generate types for, but we haven't committed it yet.
+    const response = execSync(
+        "git grep -I --word-regexp --name-only --fixed-strings --untracked 'graphql-tag' -- '*.js' '*.jsx' '*.ts' '*.tsx'",
+        {
+            encoding: "utf8",
+            cwd: root,
+        },
+    );
+    return response
+        .trim()
+        .split("\n")
+        .map((relative) => path.join(root, relative));
+};
+
+export const getInputFiles = (options: CliOptions, config: Config) => {
+    return options.cliFiles.length
+        ? options.cliFiles
+        : findGraphqlTagReferences(
+              makeAbsPath(
+                  config.crawl.root,
+                  path.dirname(options.configFilePath),
+              ),
+          );
+};
+
 /**
  * Loads a .json 'introspection query response', or a .graphql schema definition.
  */
@@ -54,6 +106,28 @@ export const getSchemas = (schemaFilePath: string): [GraphQLSchema, Schema] => {
     }
 };
 
+export const parseCliOptions = (
+    argv: string[],
+    relativeBase: string,
+): CliOptions | false => {
+    const args = processArgs(argv);
+    let [configFilePath, ...cliFiles] = args._;
+
+    if (args.h || args.help || !configFilePath) {
+        return false;
+    }
+
+    configFilePath = makeAbsPath(configFilePath, relativeBase);
+
+    const options: CliOptions = {configFilePath, cliFiles};
+
+    if (args["schema-file"]) {
+        options.schemaFile = args["schema-file"];
+    }
+
+    return options;
+};
+
 /**
  * Find the first item of the `config.generate` array where both:
  * - no item of `exclude` matches

package/src/cli/run.ts

@@ -7,7 +7,14 @@ 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 {
+    findApplicableConfig,
+    getInputFiles,
+    getSchemas,
+    loadConfigFile,
+    makeAbsPath,
+    parseCliOptions,
+} from "./config";
 
 import {addTypenameToDocument} from "apollo-utilities";
 
@@ -32,52 +39,19 @@ import {dirname} from "path";
 
 /** Step (1) */
 
-const findGraphqlTagReferences = (root: string): Array<string> => {
-    // NOTE(john): We want to include untracked files here so that we can
-    // generate types for them. This is useful for when we have a new file
-    // that we want to generate types for, but we haven't committed it yet.
-    const response = execSync(
-        "git grep -I --word-regexp --name-only --fixed-strings --untracked 'graphql-tag' -- '*.js' '*.jsx' '*.ts' '*.tsx'",
-        {
-            encoding: "utf8",
-            cwd: root,
-        },
-    );
-    return response
-        .trim()
-        .split("\n")
-        .map((relative) => path.join(root, relative));
-};
+const options = parseCliOptions(process.argv.slice(2), process.cwd());
 
-const [_, __, configFilePath, ...cliFiles] = process.argv;
-
-if (
-    configFilePath === "-h" ||
-    configFilePath === "--help" ||
-    configFilePath === "help" ||
-    !configFilePath
-) {
+if (options === false) {
     console.log(`graphql-flow
 
-Usage: graphql-flow [configFile.json] [filesToCrawl...]`);
+Usage: graphql-flow [configFile.json] [filesToCrawl...]
+Options:
+  --schema-file: provide a schema file to override the one defined in config`);
     process.exit(1);
 }
 
-const makeAbsPath = (maybeRelativePath: string, basePath: string) => {
-    return path.isAbsolute(maybeRelativePath)
-        ? maybeRelativePath
-        : path.join(basePath, maybeRelativePath);
-};
-
-const absConfigPath = makeAbsPath(configFilePath, process.cwd());
-
-const config = loadConfigFile(absConfigPath);
-
-const inputFiles = cliFiles.length
-    ? cliFiles
-    : findGraphqlTagReferences(
-          makeAbsPath(config.crawl.root, path.dirname(absConfigPath)),
-      );
+const config = loadConfigFile(options);
+const inputFiles = getInputFiles(options, config);
 
 /** Step (2) */
 
@@ -130,7 +104,7 @@ const schemaCache: {
 const getCachedSchemas = (schemaFilePath: string) => {
     if (!schemaCache[schemaFilePath]) {
         schemaCache[schemaFilePath] = getSchemas(
-            makeAbsPath(schemaFilePath, path.dirname(absConfigPath)),
+            makeAbsPath(schemaFilePath, path.dirname(options.configFilePath)),
         );
     }
 

package/src/enums.ts

@@ -28,7 +28,7 @@ export const experimentalEnumTypeToFlow = (
     }
 
     return maybeAddDescriptionComment(
-        description,
+        ctx.noComments ? null : description,
         babelTypes.tsTypeReference(enumDeclaration.id),
     );
 };
@@ -52,7 +52,7 @@ export const enumTypeToFlow = (ctx: Context, name: string): TSType => {
     return ctx.experimentalEnumsMap
         ? experimentalEnumTypeToFlow(ctx, enumConfig, combinedDescription)
         : maybeAddDescriptionComment(
-              combinedDescription,
+              ctx.noComments ? null : combinedDescription,
               babelTypes.tsUnionType(
                   enumConfig.enumValues.map((n) =>
                       babelTypes.tsLiteralType(

package/src/generateResponseType.ts

@@ -39,7 +39,7 @@ export const generateResponseType = (
         query.operation === "mutation" ? "mutation" : "query",
     );
 
-    return generate(ast as any).code;
+    return generate(ast as any, {comments: ctx.noComments ? false : true}).code;
 };
 
 const sortedObjectTypeAnnotation = (
@@ -103,7 +103,7 @@ export const generateFragmentType = (
         throw new Error(`Unknown ${onType}`);
     }
 
-    return generate(ast as any).code;
+    return generate(ast as any, {comments: ctx.noComments ? false : true}).code;
 };
 
 const _typeToFlow = (

package/src/generateVariablesType.ts

@@ -144,5 +144,7 @@ export const generateVariablesType = (
             );
         }),
     );
-    return generate(variableObject as any).code;
+    return generate(variableObject as any, {
+        comments: ctx.noComments ? false : true,
+    }).code;
 };

package/src/index.ts

@@ -31,6 +31,7 @@ const optionsToConfig = (
         scalars: options?.scalars ?? {},
         typeScript: options?.typeScript ?? false,
         omitFileExtensions: options?.omitFileExtensions ?? false,
+        noComments: options?.noComments,
     } as const;
     const fragments: Record<string, any> = {};
     definitions.forEach((def) => {
@@ -101,9 +102,10 @@ export const documentToFlowTypes = (
                     },
                 )};`;
 
-                const extraTypes = codegenExtraTypes(types);
+                const extraTypes = codegenExtraTypes(types, config);
                 const experimentalEnums = codegenExtraTypes(
                     config.experimentalEnumsMap || {},
+                    config,
                 );
 
                 return {
@@ -139,9 +141,10 @@ export const documentToFlowTypes = (
                 // We'll see what's required to get webapp on board.
                 const code = `export type ${typeName} = {\n    variables: ${variables},\n    response: ${response}\n};`;
 
-                const extraTypes = codegenExtraTypes(types);
+                const extraTypes = codegenExtraTypes(types, config);
                 const experimentalEnums = codegenExtraTypes(
                     config.experimentalEnumsMap || {},
+                    config,
                 );
 
                 return {name, typeName, code, extraTypes, experimentalEnums};
@@ -154,14 +157,19 @@ export const documentToFlowTypes = (
     return result;
 };
 
-function codegenExtraTypes(types: {[key: string]: Node}): {
+function codegenExtraTypes(
+    types: {[key: string]: Node},
+    ctx: Context,
+): {
     [key: string]: string;
 } {
     const extraTypes: {
         [key: string]: string;
     } = {};
     Object.keys(types).forEach((k: string) => {
-        extraTypes[k] = generate(types[k] as any).code;
+        extraTypes[k] = generate(types[k] as any, {
+            comments: ctx.noComments ? false : true,
+        }).code;
     });
     return extraTypes;
 }

package/src/types.ts

@@ -10,6 +10,12 @@ import type {
     SelectionNode,
 } from "graphql";
 
+export type CliOptions = {
+    schemaFile?: string;
+    configFilePath: string;
+    cliFiles: string[];
+};
+
 export type Selections = ReadonlyArray<SelectionNode>;
 
 export type GenerateConfig = {
@@ -18,6 +24,7 @@ export type GenerateConfig = {
     exclude?: ReadonlyArray<RegExp | string>;
     typeScript?: boolean;
     scalars?: Scalars;
+    noComments?: boolean;
     strictNullability?: boolean;
     /**
      * The command that users should run to regenerate the types files.
@@ -81,6 +88,7 @@ export type Schema = {
 export type Context = {
     path: Array<string>;
     strictNullability: boolean;
+    noComments: boolean;
     readOnlyArray: boolean;
     fragments: {
         [key: string]: FragmentDefinitionNode;