@khanacademy/graphql-flow 0.0.1

package/dist/index.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.documentToFlowTypes = exports.FlowGenerationError = void 0;
+Object.defineProperty(exports, "spyOnGraphqlTagToCollectQueries", {
+  enumerable: true,
+  get: function () {
+    return _jestMockGraphqlTag.spyOnGraphqlTagToCollectQueries;
+  }
+});
+
+var _generateResponseType = require("./generateResponseType");
+
+var _generateVariablesType = require("./generateVariablesType");
+
+var _jestMockGraphqlTag = require("./jest-mock-graphql-tag");
+
+/* eslint-disable no-console */
+
+/* flow-uncovered-file */
+
+/**
+ * This tool generates flowtype definitions from graphql queries.
+ *
+ * It relies on `introspection-query.json` existing in this directory,
+ * which is produced by running `./tools/graphql-flow/sendIntrospection.js`.
+ */
+const optionsToConfig = (schema, definitions, options, errors = []) => {
+  const internalOptions = {
+    strictNullability: (options === null || options === void 0 ? void 0 : options.strictNullability) ?? true,
+    readOnlyArray: (options === null || options === void 0 ? void 0 : options.readOnlyArray) ?? true,
+    scalars: (options === null || options === void 0 ? void 0 : options.scalars) ?? {}
+  };
+  const fragments = {};
+  definitions.forEach(def => {
+    if (def.kind === 'FragmentDefinition') {
+      fragments[def.name.value] = def;
+    }
+  });
+  const config = {
+    fragments,
+    schema,
+    errors,
+    ...internalOptions
+  };
+  return config;
+};
+
+class FlowGenerationError extends Error {
+  constructor(errors) {
+    super(`Graphql-flow type generation failed! ${errors.join('; ')}`);
+    this.messages = errors;
+  }
+
+}
+
+exports.FlowGenerationError = FlowGenerationError;
+
+const documentToFlowTypes = (document, schema, options) => {
+  const errors = [];
+  const config = optionsToConfig(schema, document.definitions, options, errors);
+  const result = document.definitions.map(item => {
+    if (item.kind === 'OperationDefinition' && (item.operation === 'query' || item.operation === 'mutation') && item.name) {
+      const name = item.name.value;
+      const response = (0, _generateResponseType.generateResponseType)(schema, item, config);
+      const variables = (0, _generateVariablesType.generateVariablesType)(schema, item, config);
+      const typeName = `${name}Type`; // 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|};`;
+      return {
+        name,
+        typeName,
+        code
+      };
+    }
+  }).filter(Boolean);
+
+  if (errors.length) {
+    throw new FlowGenerationError(errors);
+  }
+
+  return result;
+};
+
+exports.documentToFlowTypes = documentToFlowTypes;

package/dist/index.js.flow

@@ -0,0 +1,93 @@
+/* eslint-disable no-console */
+/* flow-uncovered-file */
+// @flow
+/**
+ * This tool generates flowtype definitions from graphql queries.
+ *
+ * It relies on `introspection-query.json` existing in this directory,
+ * which is produced by running `./tools/graphql-flow/sendIntrospection.js`.
+ */
+import type {DefinitionNode, DocumentNode} from 'graphql';
+
+import {generateResponseType} from './generateResponseType';
+import {generateVariablesType} from './generateVariablesType';
+export {spyOnGraphqlTagToCollectQueries} from './jest-mock-graphql-tag';
+
+import type {Config, Options, Schema} from './types';
+
+const optionsToConfig = (
+    schema: Schema,
+    definitions: $ReadOnlyArray<DefinitionNode>,
+    options?: Options,
+    errors: Array<string> = [],
+): Config => {
+    const internalOptions = {
+        strictNullability: options?.strictNullability ?? true,
+        readOnlyArray: options?.readOnlyArray ?? true,
+        scalars: options?.scalars ?? {},
+    };
+    const fragments = {};
+    definitions.forEach((def) => {
+        if (def.kind === 'FragmentDefinition') {
+            fragments[def.name.value] = def;
+        }
+    });
+    const config = {
+        fragments,
+        schema,
+        errors,
+        ...internalOptions,
+    };
+
+    return config;
+};
+
+export class FlowGenerationError extends Error {
+    messages: Array<string>;
+    constructor(errors: Array<string>) {
+        super(`Graphql-flow type generation failed! ${errors.join('; ')}`);
+        this.messages = errors;
+    }
+}
+
+export const documentToFlowTypes = (
+    document: DocumentNode,
+    schema: Schema,
+    options?: Options,
+): $ReadOnlyArray<{
+    name: string,
+    typeName: string,
+    code: string,
+}> => {
+    const errors: Array<string> = [];
+    const config = optionsToConfig(
+        schema,
+        document.definitions,
+        options,
+        errors,
+    );
+    const result = document.definitions
+        .map((item) => {
+            if (
+                item.kind === 'OperationDefinition' &&
+                (item.operation === 'query' || item.operation === 'mutation') &&
+                item.name
+            ) {
+                const name = item.name.value;
+                const response = generateResponseType(schema, item, config);
+                const variables = generateVariablesType(schema, item, config);
+
+                const typeName = `${name}Type`;
+                // 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|};`;
+
+                return {name, typeName, code};
+            }
+        })
+        .filter(Boolean);
+    if (errors.length) {
+        throw new FlowGenerationError(errors);
+    }
+    return result;
+};

package/dist/jest-mock-graphql-tag.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _validation = require("graphql/validation");
+
+var _graphql = require("graphql");
+
+var _printer = require("graphql/language/printer");
+
+var _apolloUtilities = require("apollo-utilities");
+
+var _schemaFromIntrospectionData = require("./schemaFromIntrospectionData");
+
+// Import this in your jest setup, to mock out graphql-tag!
+// eslint-disable-line flowtype-errors/uncovered
+const indexPrelude = `// @flow
+//
+// AUTOGENERATED
+// NOTE: New response types are added to this file automatically.
+//       Outdated response types can be removed manually as they are deprecated.
+//
+
+`;
+
+const generateTypeFiles = (schema, document, options) => {
+  const {
+    documentToFlowTypes
+  } = require('.');
+
+  const path = require('path');
+
+  const fs = require('fs');
+
+  const format = require('prettier-eslint'); // eslint-disable-line flowtype-errors/uncovered
+
+
+  const indexFile = generatedDir => path.join(generatedDir, 'index.js');
+
+  const maybeCreateGeneratedDir = generatedDir => {
+    if (!fs.existsSync(generatedDir)) {
+      fs.mkdirSync(generatedDir, {
+        recursive: true
+      }); // Now write an index.js for each __generated__ dir.
+
+      fs.writeFileSync(indexFile(generatedDir), indexPrelude);
+    }
+  }; /// Write export for __generated__/index.js if it doesn't exist
+
+
+  const writeToIndex = (filePath, typeName) => {
+    const index = indexFile(path.dirname(filePath));
+    const indexContents = fs.readFileSync(index, 'utf8');
+    const newLine = `export type {${typeName}} from './${path.basename(filePath)}';`;
+
+    if (indexContents.indexOf(path.basename(filePath)) === -1) {
+      fs.appendFileSync(index, newLine + '\n');
+    } else {
+      const lines = indexContents.split('\n').map(line => {
+        if (line.includes(path.basename(filePath))) {
+          return newLine;
+        }
+
+        return line;
+      });
+      fs.writeFileSync(index, lines.join('\n'));
+    }
+  }; // Get the name of the file that `gql` was called from
+
+
+  const errorLines = new Error().stack.split('\n');
+  const fileName = errorLines[3].split('(').slice(-1)[0].split(':')[0];
+  const generated = documentToFlowTypes(document, schema, options);
+  generated.forEach(({
+    name,
+    typeName,
+    code
+  }) => {
+    // We write all generated files to a `__generated__` subdir to keep
+    // things tidy.
+    const targetFileName = `${typeName}.js`;
+    const generatedDir = path.join(path.dirname(fileName), '__generated__');
+    const targetPath = path.join(generatedDir, targetFileName);
+    maybeCreateGeneratedDir(generatedDir); // NOTE: Uncomment this to write the query definitions to disk if
+    // you need to add new features to the flow type generation
+    // fs.writeFileSync(
+    //     targetFileName + '.query',
+    //     JSON.stringify(definitions, null, 2),
+    // );
+
+    const fileContents = format({
+      text: '// @' + `flow\n// AUTOGENERATED -- DO NOT EDIT\n` + `// Generated for operation '${name}' in file '../${path.basename(fileName)}'\n` + `// To regenerate, run 'yarn test queries'.\n` + code
+    });
+    fs.writeFileSync(targetPath, fileContents);
+    writeToIndex(targetPath, typeName);
+  });
+};
+
+// This function is expected to be called like so:
+//
+// jest.mock('graphql-tag', () => {
+//     const introspectionData = jest.requireActual(
+//         './our-introspection-query.json',
+//     );
+//     const {spyOnGraphqlTagToCollectQueries} = jest.requireActual(
+//         'graphql-flow/jest-mock-graphql-tag.js');
+//
+//     return spyOnGraphqlTagToCollectQueries(
+//         jest.requireActual('graphql-tag'),
+//         introspectionData,
+//     );
+// });
+//
+// If both pragma and loosePragma are empty, then all graphql
+// documents will be processed. Otherwise, only documents
+// with one of the pragmas will be processed.
+const spyOnGraphqlTagToCollectQueries = (realGraphqlTag, introspectionData, options = {}) => {
+  const collection = [];
+  const clientSchema = (0, _graphql.buildClientSchema)(introspectionData);
+  const schema = (0, _schemaFromIntrospectionData.schemaFromIntrospectionData)(introspectionData);
+
+  const wrapper = function gql() {
+    const document = realGraphqlTag.apply(this, arguments); // eslint-disable-line flowtype-errors/uncovered
+
+    const hasNonFragments = document.definitions.some(({
+      kind
+    }) => kind !== 'FragmentDefinition');
+
+    if (hasNonFragments) {
+      // eslint-disable-next-line flowtype-errors/uncovered
+      const withTypeNames = (0, _apolloUtilities.addTypenameToDocument)(document);
+      collection.push({
+        raw: (0, _printer.print)(withTypeNames),
+        errors: (0, _validation.validate)(clientSchema, document)
+      });
+      const rawSource = arguments[0].raw[0]; // eslint-disable-line flowtype-errors/uncovered
+
+      const processedOptions = processPragmas(options, rawSource);
+
+      if (processedOptions) {
+        generateTypeFiles(schema, withTypeNames, processedOptions);
+      }
+    }
+
+    return document;
+  };
+
+  wrapper.collectedQueries = collection;
+  return wrapper;
+};
+
+const processPragmas = (options, rawSource) => {
+  const autogen = options.loosePragma ? rawSource.includes(options.loosePragma) : false;
+  const autogenStrict = options.pragma ? rawSource.includes(options.pragma) : false;
+  const noPragmas = !options.loosePragma && !options.pragma;
+
+  if (autogen || autogenStrict || noPragmas) {
+    return {
+      strictNullability: noPragmas ? options.strictNullability : autogenStrict || !autogen,
+      readOnlyArray: options.readOnlyArray,
+      scalars: options.scalars
+    };
+  } else {
+    return null;
+  }
+};
+
+module.exports = {
+  processPragmas,
+  spyOnGraphqlTagToCollectQueries
+};

package/dist/jest-mock-graphql-tag.js.flow

@@ -0,0 +1,191 @@
+// @flow
+// Import this in your jest setup, to mock out graphql-tag!
+import type {DocumentNode, IntrospectionQuery} from 'graphql';
+import type {Schema, Options, Scalars} from './types';
+import {validate} from 'graphql/validation';
+import {buildClientSchema} from 'graphql';
+import {print} from 'graphql/language/printer';
+import {addTypenameToDocument} from 'apollo-utilities'; // eslint-disable-line flowtype-errors/uncovered
+import {schemaFromIntrospectionData} from './schemaFromIntrospectionData';
+
+const indexPrelude = `// @flow
+//
+// AUTOGENERATED
+// NOTE: New response types are added to this file automatically.
+//       Outdated response types can be removed manually as they are deprecated.
+//
+
+`;
+
+const generateTypeFiles = (
+    schema: Schema,
+    document: DocumentNode,
+    options: Options,
+) => {
+    const {documentToFlowTypes} = require('.');
+    const path = require('path');
+    const fs = require('fs');
+    const format: ({text: string}) => string = require('prettier-eslint'); // eslint-disable-line flowtype-errors/uncovered
+
+    const indexFile = (generatedDir) => path.join(generatedDir, 'index.js');
+
+    const maybeCreateGeneratedDir = (generatedDir) => {
+        if (!fs.existsSync(generatedDir)) {
+            fs.mkdirSync(generatedDir, {recursive: true});
+
+            // Now write an index.js for each __generated__ dir.
+            fs.writeFileSync(indexFile(generatedDir), indexPrelude);
+        }
+    };
+
+    /// Write export for __generated__/index.js if it doesn't exist
+    const writeToIndex = (filePath, typeName) => {
+        const index = indexFile(path.dirname(filePath));
+        const indexContents = fs.readFileSync(index, 'utf8');
+        const newLine = `export type {${typeName}} from './${path.basename(
+            filePath,
+        )}';`;
+        if (indexContents.indexOf(path.basename(filePath)) === -1) {
+            fs.appendFileSync(index, newLine + '\n');
+        } else {
+            const lines = indexContents.split('\n').map((line) => {
+                if (line.includes(path.basename(filePath))) {
+                    return newLine;
+                }
+                return line;
+            });
+            fs.writeFileSync(index, lines.join('\n'));
+        }
+    };
+
+    // Get the name of the file that `gql` was called from
+    const errorLines = new Error().stack.split('\n');
+    const fileName = errorLines[3].split('(').slice(-1)[0].split(':')[0];
+
+    const generated = documentToFlowTypes(document, schema, options);
+    generated.forEach(({name, typeName, code}) => {
+        // We write all generated files to a `__generated__` subdir to keep
+        // things tidy.
+        const targetFileName = `${typeName}.js`;
+        const generatedDir = path.join(path.dirname(fileName), '__generated__');
+        const targetPath = path.join(generatedDir, targetFileName);
+
+        maybeCreateGeneratedDir(generatedDir);
+
+        // NOTE: Uncomment this to write the query definitions to disk if
+        // you need to add new features to the flow type generation
+        // fs.writeFileSync(
+        //     targetFileName + '.query',
+        //     JSON.stringify(definitions, null, 2),
+        // );
+        const fileContents = format({
+            text:
+                '// @' +
+                `flow\n// AUTOGENERATED -- DO NOT EDIT\n` +
+                `// Generated for operation '${name}' in file '../${path.basename(
+                    fileName,
+                )}'\n` +
+                `// To regenerate, run 'yarn test queries'.\n` +
+                code,
+        });
+        fs.writeFileSync(targetPath, fileContents);
+
+        writeToIndex(targetPath, typeName);
+    });
+};
+
+type GraphqlTagFn = (raw: string, ...args: Array<any>) => DocumentNode;
+
+type SpyOptions = {
+    pragma?: string,
+    loosePragma?: string,
+    scalars?: Scalars,
+    strictNullability?: boolean,
+    readOnlyArray?: boolean,
+};
+
+// This function is expected to be called like so:
+//
+// jest.mock('graphql-tag', () => {
+//     const introspectionData = jest.requireActual(
+//         './our-introspection-query.json',
+//     );
+//     const {spyOnGraphqlTagToCollectQueries} = jest.requireActual(
+//         'graphql-flow/jest-mock-graphql-tag.js');
+//
+//     return spyOnGraphqlTagToCollectQueries(
+//         jest.requireActual('graphql-tag'),
+//         introspectionData,
+//     );
+// });
+//
+// If both pragma and loosePragma are empty, then all graphql
+// documents will be processed. Otherwise, only documents
+// with one of the pragmas will be processed.
+const spyOnGraphqlTagToCollectQueries = (
+    realGraphqlTag: GraphqlTagFn,
+    introspectionData: IntrospectionQuery,
+    options: SpyOptions = {},
+): GraphqlTagFn => {
+    const collection: Array<{
+        raw: string,
+        errors: $ReadOnlyArray<Error>,
+    }> = [];
+
+    const clientSchema = buildClientSchema(introspectionData);
+    const schema = schemaFromIntrospectionData(introspectionData);
+
+    const wrapper = function gql() {
+        const document: DocumentNode = realGraphqlTag.apply(this, arguments); // eslint-disable-line flowtype-errors/uncovered
+        const hasNonFragments = document.definitions.some(
+            ({kind}) => kind !== 'FragmentDefinition',
+        );
+        if (hasNonFragments) {
+            // eslint-disable-next-line flowtype-errors/uncovered
+            const withTypeNames: DocumentNode = addTypenameToDocument(document);
+            collection.push({
+                raw: print(withTypeNames),
+                errors: validate(clientSchema, document),
+            });
+
+            const rawSource: string = arguments[0].raw[0]; // eslint-disable-line flowtype-errors/uncovered
+            const processedOptions = processPragmas(options, rawSource);
+            if (processedOptions) {
+                generateTypeFiles(schema, withTypeNames, processedOptions);
+            }
+        }
+        return document;
+    };
+    wrapper.collectedQueries = collection;
+    return wrapper;
+};
+
+const processPragmas = (
+    options: SpyOptions,
+    rawSource: string,
+): null | Options => {
+    const autogen = options.loosePragma
+        ? rawSource.includes(options.loosePragma)
+        : false;
+    const autogenStrict = options.pragma
+        ? rawSource.includes(options.pragma)
+        : false;
+    const noPragmas = !options.loosePragma && !options.pragma;
+
+    if (autogen || autogenStrict || noPragmas) {
+        return {
+            strictNullability: noPragmas
+                ? options.strictNullability
+                : autogenStrict || !autogen,
+            readOnlyArray: options.readOnlyArray,
+            scalars: options.scalars,
+        };
+    } else {
+        return null;
+    }
+};
+
+module.exports = {
+    processPragmas,
+    spyOnGraphqlTagToCollectQueries,
+};

package/dist/schemaFromIntrospectionData.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.schemaFromIntrospectionData = void 0;
+
+/**
+ * Takes the introspectionQuery response and parses it into the "Schema"
+ * type that we use to look up types, interfaces, etc.
+ */
+const schemaFromIntrospectionData = schema => {
+  const result = {
+    interfacesByName: {},
+    typesByName: {},
+    inputObjectsByName: {},
+    unionsByName: {},
+    enumsByName: {}
+  };
+
+  schema.__schema.types.forEach(type => {
+    if (type.kind === 'ENUM') {
+      result.enumsByName[type.name] = type;
+      return;
+    }
+
+    if (type.kind === 'UNION') {
+      result.unionsByName[type.name] = type;
+      return;
+    }
+
+    if (type.kind === 'INTERFACE') {
+      result.interfacesByName[type.name] = { ...type,
+        possibleTypesByName: {},
+        fieldsByName: {}
+      };
+      type.possibleTypes.forEach(p => result.interfacesByName[type.name].possibleTypesByName[p.name] = true);
+      type.fields.forEach(field => {
+        result.interfacesByName[type.name].fieldsByName[field.name] = field;
+      });
+      return;
+    }
+
+    if (type.kind === 'INPUT_OBJECT') {
+      result.inputObjectsByName[type.name] = type;
+      return;
+    }
+
+    if (type.kind === 'SCALAR') {
+      return;
+    }
+
+    result.typesByName[type.name] = { ...type,
+      fieldsByName: {}
+    };
+
+    if (!type.fields) {
+      return;
+    }
+
+    type.fields.forEach(field => {
+      result.typesByName[type.name].fieldsByName[field.name] = field;
+    });
+  });
+
+  return result;
+};
+
+exports.schemaFromIntrospectionData = schemaFromIntrospectionData;

package/dist/schemaFromIntrospectionData.js.flow

@@ -0,0 +1,68 @@
+// @flow
+/**
+ * Takes the introspectionQuery response and parses it into the "Schema"
+ * type that we use to look up types, interfaces, etc.
+ */
+import type {IntrospectionQuery} from 'graphql';
+import type {Schema} from './types';
+
+export const schemaFromIntrospectionData = (
+    schema: IntrospectionQuery,
+): Schema => {
+    const result: Schema = {
+        interfacesByName: {},
+        typesByName: {},
+        inputObjectsByName: {},
+        unionsByName: {},
+        enumsByName: {},
+    };
+
+    schema.__schema.types.forEach((type) => {
+        if (type.kind === 'ENUM') {
+            result.enumsByName[type.name] = type;
+            return;
+        }
+        if (type.kind === 'UNION') {
+            result.unionsByName[type.name] = type;
+            return;
+        }
+        if (type.kind === 'INTERFACE') {
+            result.interfacesByName[type.name] = {
+                ...type,
+                possibleTypesByName: {},
+                fieldsByName: {},
+            };
+            type.possibleTypes.forEach(
+                (p) =>
+                    (result.interfacesByName[type.name].possibleTypesByName[
+                        p.name
+                    ] = true),
+            );
+            type.fields.forEach((field) => {
+                result.interfacesByName[type.name].fieldsByName[field.name] =
+                    field;
+            });
+            return;
+        }
+        if (type.kind === 'INPUT_OBJECT') {
+            result.inputObjectsByName[type.name] = type;
+            return;
+        }
+        if (type.kind === 'SCALAR') {
+            return;
+        }
+        result.typesByName[type.name] = {
+            ...type,
+            fieldsByName: {},
+        };
+        if (!type.fields) {
+            return;
+        }
+
+        type.fields.forEach((field) => {
+            result.typesByName[type.name].fieldsByName[field.name] = field;
+        });
+    });
+
+    return result;
+};

package/dist/types.js

@@ -0,0 +1 @@
+"use strict";