@khanacademy/graphql-flow 0.0.1

package/dist/enums.js.flow

@@ -0,0 +1,69 @@
+// @flow
+/**
+ * Both input & output types can have enums & scalars.
+ */
+import * as babelTypes from '@babel/types';
+import {type BabelNodeFlowType} from '@babel/types';
+import type {Config} from './types';
+import {maybeAddDescriptionComment} from './utils';
+
+export const enumTypeToFlow = (
+    config: Config,
+    name: string,
+): BabelNodeFlowType => {
+    const enumConfig = config.schema.enumsByName[name];
+    let combinedDescription = enumConfig.enumValues
+        .map(
+            (n) =>
+                `- ${n.name}` +
+                (n.description
+                    ? '\n\n      ' + n.description.replace(/\n/g, '\n      ')
+                    : ''),
+        )
+        .join('\n');
+    if (enumConfig.description) {
+        combinedDescription =
+            enumConfig.description + '\n\n' + combinedDescription;
+    }
+    return maybeAddDescriptionComment(
+        combinedDescription,
+        babelTypes.unionTypeAnnotation(
+            enumConfig.enumValues.map((n) =>
+                babelTypes.stringLiteralTypeAnnotation(n.name),
+            ),
+        ),
+    );
+};
+
+export const builtinScalars: {[key: string]: string} = {
+    Boolean: 'boolean',
+    String: 'string',
+    DateTime: 'string',
+    Date: 'string',
+    ID: 'string',
+    Int: 'number',
+    Float: 'number',
+};
+
+export const scalarTypeToFlow = (
+    config: Config,
+    name: string,
+): BabelNodeFlowType => {
+    if (builtinScalars[name]) {
+        return babelTypes.genericTypeAnnotation(
+            babelTypes.identifier(builtinScalars[name]),
+        );
+    }
+    const underlyingType = config.scalars[name];
+    if (underlyingType != null) {
+        return babelTypes.genericTypeAnnotation(
+            babelTypes.identifier(underlyingType),
+        );
+    }
+    config.errors.push(
+        `Unexpected scalar '${name}'! Please add it to the "scalars" argument at the callsite of 'generateFlowTypes()'.`,
+    );
+    return babelTypes.genericTypeAnnotation(
+        babelTypes.identifier(`UNKNOWN_SCALAR["${name}"]`),
+    );
+};

package/dist/generateResponseType.js

@@ -0,0 +1,267 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unionOrInterfaceToFlow = exports.typeToFlow = exports.objectPropertiesToFlow = exports.generateResponseType = void 0;
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var babelTypes = _interopRequireWildcard(require("@babel/types"));
+
+var _utils = require("./utils");
+
+var _enums = require("./enums");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable no-console */
+// eslint-disable-line flowtype-errors/uncovered
+const generateResponseType = (schema, query, config) => {
+  const ast = querySelectionToObjectType(config, query.selectionSet.selections, query.operation === 'mutation' ? schema.typesByName.Mutation : schema.typesByName.Query, query.operation === 'mutation' ? 'mutation' : 'query'); // eslint-disable-next-line flowtype-errors/uncovered
+
+  return (0, _generator.default)(ast).code;
+};
+
+exports.generateResponseType = generateResponseType;
+
+const _typeToFlow = (config, type, selection) => {
+  if (type.kind === 'SCALAR') {
+    return (0, _enums.scalarTypeToFlow)(config, type.name);
+  }
+
+  if (type.kind === 'LIST') {
+    return babelTypes.genericTypeAnnotation(config.readOnlyArray ? babelTypes.identifier('$ReadOnlyArray') : babelTypes.identifier('Array'), babelTypes.typeParameterInstantiation([typeToFlow(config, type.ofType, selection)]));
+  }
+
+  if (type.kind === 'UNION') {
+    const union = config.schema.unionsByName[type.name];
+
+    if (!selection.selectionSet) {
+      console.log('no selection set', selection);
+      return babelTypes.anyTypeAnnotation();
+    }
+
+    return unionOrInterfaceToFlow(config, union, selection.selectionSet.selections);
+  }
+
+  if (type.kind === 'INTERFACE') {
+    if (!selection.selectionSet) {
+      console.log('no selection set', selection);
+      return babelTypes.anyTypeAnnotation();
+    }
+
+    return unionOrInterfaceToFlow(config, config.schema.interfacesByName[type.name], selection.selectionSet.selections);
+  }
+
+  if (type.kind === 'ENUM') {
+    return (0, _enums.enumTypeToFlow)(config, type.name);
+  }
+
+  if (type.kind !== 'OBJECT') {
+    console.log('not object', type);
+    return babelTypes.anyTypeAnnotation();
+  }
+
+  const tname = type.name;
+
+  if (!config.schema.typesByName[tname]) {
+    console.log('unknown referenced type', tname);
+    return babelTypes.anyTypeAnnotation();
+  }
+
+  const childType = config.schema.typesByName[tname];
+
+  if (!selection.selectionSet) {
+    console.log('no selection set', selection);
+    return babelTypes.anyTypeAnnotation();
+  }
+
+  return (0, _utils.maybeAddDescriptionComment)(childType.description, querySelectionToObjectType(config, selection.selectionSet.selections, childType, tname));
+};
+
+const typeToFlow = (config, type, selection) => {
+  // throw new Error('npoe');
+  if (type.kind === 'NON_NULL') {
+    return _typeToFlow(config, type.ofType, selection);
+  } // If we don'babelTypes care about strict nullability checking, then pretend everything is non-null
+
+
+  if (!config.strictNullability) {
+    return _typeToFlow(config, type, selection);
+  }
+
+  const inner = _typeToFlow(config, type, selection);
+
+  const result = babelTypes.nullableTypeAnnotation(inner);
+  return (0, _utils.transferLeadingComments)(inner, result);
+};
+
+exports.typeToFlow = typeToFlow;
+
+const querySelectionToObjectType = (config, selections, type, typeName) => {
+  let seenTypeName = false;
+  return babelTypes.objectTypeAnnotation(objectPropertiesToFlow(config, type, typeName, selections).filter(type => {
+    // The apollo-utilities "addTypeName" utility will add it
+    // even if it's already specified :( so we have to filter out
+    // the extra one here.
+    if (type.type === 'ObjectTypeProperty' && type.key.name === '__typename') {
+      if (seenTypeName) {
+        return false;
+      }
+
+      seenTypeName = true;
+    }
+
+    return true;
+  }), undefined
+  /* indexers */
+  , undefined
+  /* callProperties */
+  , undefined
+  /* internalSlots */
+  , true
+  /* exact */
+  );
+};
+
+const objectPropertiesToFlow = (config, type, typeName, selections) => {
+  return [].concat(...selections.map(selection => {
+    switch (selection.kind) {
+      case 'FragmentSpread':
+        if (!config.fragments[selection.name.value]) {
+          config.errors.push(`No fragment named '${selection.name.value}'. Did you forget to include it in the template literal?`);
+          return [babelTypes.objectTypeProperty(babelTypes.identifier(selection.name.value), babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_FRAGMENT`)))];
+        }
+
+        return objectPropertiesToFlow(config, type, typeName, config.fragments[selection.name.value].selectionSet.selections);
+
+      case 'Field':
+        const name = selection.name.value;
+        const alias = selection.alias ? selection.alias.value : name;
+
+        if (name === '__typename') {
+          return [babelTypes.objectTypeProperty(babelTypes.identifier(alias), babelTypes.stringLiteralTypeAnnotation(typeName))];
+        }
+
+        if (!type.fieldsByName[name]) {
+          config.errors.push(`Unknown field '${name}' for type '${typeName}'`);
+          return babelTypes.objectTypeProperty(babelTypes.identifier(alias), babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_FIELD["${name}"]`)));
+        }
+
+        const typeField = type.fieldsByName[name];
+        return [(0, _utils.maybeAddDescriptionComment)(typeField.description, (0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow(config, typeField.type, selection))))];
+
+      default:
+        config.errors.push(`Unsupported selection kind '${selection.kind}'`);
+        return [];
+    }
+  }));
+};
+
+exports.objectPropertiesToFlow = objectPropertiesToFlow;
+
+const unionOrInterfaceToFlow = (config, type, selections) => {
+  const selectedAttributes = type.possibleTypes.map(possible => {
+    let seenTypeName = false;
+    return selections.map(selection => unionOrInterfaceSelection(config, type, possible, selection)).flat().filter(type => {
+      // The apollo-utilities "addTypeName" utility will add it
+      // even if it's already specified :( so we have to filter out
+      // the extra one here.
+      if (type.type === 'ObjectTypeProperty' && type.key.name === '__typename') {
+        if (seenTypeName) {
+          return false;
+        }
+
+        seenTypeName = true;
+      }
+
+      return true;
+    });
+  });
+  const allFields = selections.every(selection => selection.kind === 'Field');
+
+  if (selectedAttributes.length === 1 || allFields) {
+    return babelTypes.objectTypeAnnotation(selectedAttributes[0], undefined
+    /* indexers */
+    , undefined
+    /* callProperties */
+    , undefined
+    /* internalSlots */
+    , true
+    /* exact */
+    );
+  }
+
+  return babelTypes.unionTypeAnnotation(selectedAttributes.map(properties => babelTypes.objectTypeAnnotation(properties, undefined
+  /* indexers */
+  , undefined
+  /* callProperties */
+  , undefined
+  /* internalSlots */
+  , true
+  /* exact */
+  )));
+};
+
+exports.unionOrInterfaceToFlow = unionOrInterfaceToFlow;
+
+const unionOrInterfaceSelection = (config, type, possible, selection) => {
+  if (selection.kind === 'Field' && selection.name.value === '__typename') {
+    const alias = selection.alias ? selection.alias.value : selection.name.value;
+    return [babelTypes.objectTypeProperty(babelTypes.identifier(alias), babelTypes.stringLiteralTypeAnnotation(possible.name))];
+  }
+
+  if (selection.kind === 'Field' && type.kind !== 'UNION') {
+    // this is an interface
+    const name = selection.name.value;
+    const alias = selection.alias ? selection.alias.value : name;
+
+    if (!type.fieldsByName[name]) {
+      config.errors.push('Unknown field: ' + name + ' on type ' + type.name + ' for possible ' + possible.name);
+      return [babelTypes.objectTypeProperty(babelTypes.identifier(alias), babelTypes.genericTypeAnnotation(babelTypes.identifier(`UNKNOWN_FIELD`)))];
+    }
+
+    const typeField = type.fieldsByName[name];
+    return [(0, _utils.liftLeadingPropertyComments)(babelTypes.objectTypeProperty(babelTypes.identifier(alias), typeToFlow(config, typeField.type, selection)))];
+  }
+
+  if (selection.kind === 'FragmentSpread') {
+    const fragment = config.fragments[selection.name.value];
+    const typeName = fragment.typeCondition.name.value;
+
+    if (config.schema.interfacesByName[typeName] && config.schema.interfacesByName[typeName].possibleTypesByName[possible.name] || typeName === possible.name) {
+      return [].concat(...fragment.selectionSet.selections.map(selection => unionOrInterfaceSelection(config, config.schema.typesByName[possible.name], possible, selection)));
+    } else {
+      return [];
+    }
+  }
+
+  if (selection.kind !== 'InlineFragment') {
+    config.errors.push(`union selectors must be inline fragment: found ${selection.kind}`);
+
+    if (type.kind === 'UNION') {
+      config.errors.push(`You're trying to select a field from the union ${type.name},
+but the only field you're allowed to select is "__typename".
+Try using an inline fragment "... on SomeType {}".`);
+    }
+
+    return [];
+  }
+
+  if (!selection.typeCondition) {
+    throw new Error('Expected selection to have a typeCondition');
+  }
+
+  const typeName = selection.typeCondition.name.value;
+
+  if (config.schema.interfacesByName[typeName] && config.schema.interfacesByName[typeName].possibleTypesByName[possible.name] || typeName === possible.name) {
+    return objectPropertiesToFlow(config, config.schema.typesByName[possible.name], possible.name, selection.selectionSet.selections);
+  }
+
+  return [];
+};