@graphitation/apollo-react-relay-duct-tape-compiler 1.5.6 → 1.6.1

package/lib/typescriptTransforms/TypeScriptGenerator.mjs

@@ -0,0 +1,904 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/typescriptTransforms/TypeScriptGenerator.ts
+import {
+  IRVisitor
+} from "relay-compiler";
+import * as FlattenTransform from "relay-compiler/lib/transforms/FlattenTransform";
+import * as MaskTransform from "relay-compiler/lib/transforms/MaskTransform";
+import * as MatchTransform from "relay-compiler/lib/transforms/MatchTransform";
+import * as RefetchableFragmentTransform from "relay-compiler/lib/transforms/RefetchableFragmentTransform";
+import * as RelayDirectiveTransform from "relay-compiler/lib/transforms/RelayDirectiveTransform";
+import * as ts from "typescript";
+import {
+  transformInputType,
+  transformScalarType
+} from "./TypeScriptTypeTransformers.mjs";
+var REF_TYPE = " $refType";
+var FRAGMENT_REFS = " $fragmentRefs";
+var DATA_REF = " $data";
+var FRAGMENT_REFS_TYPE_NAME = "FragmentRefs";
+var DIRECTIVE_NAME = "raw_response_type";
+var generate = (schema, node, options) => {
+  const ast = aggregateRuntimeImports(
+    IRVisitor.visit(node, createVisitor(schema, options))
+  );
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const resultFile = ts.createSourceFile(
+    "graphql-def.ts",
+    "",
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.TS
+  );
+  const fullProgramAst = ts.factory.updateSourceFile(resultFile, ast);
+  return printer.printNode(ts.EmitHint.SourceFile, fullProgramAst, resultFile);
+};
+function aggregateRuntimeImports(ast) {
+  const importNodes = ast.filter(
+    (declaration) => ts.isImportDeclaration(declaration)
+  );
+  const runtimeImports = importNodes.filter(
+    (importDeclaration) => importDeclaration.moduleSpecifier.text === "relay-runtime"
+  );
+  if (runtimeImports.length > 1) {
+    const namedImports = [];
+    runtimeImports.map((node) => {
+      node.importClause.namedBindings.elements.map(
+        (element) => {
+          namedImports.push(element.name.text);
+        }
+      );
+    });
+    const importSpecifiers = [];
+    namedImports.map((namedImport) => {
+      const specifier = ts.factory.createImportSpecifier(
+        false,
+        void 0,
+        ts.factory.createIdentifier(namedImport)
+      );
+      importSpecifiers.push(specifier);
+    });
+    const namedBindings = ts.factory.createNamedImports(importSpecifiers);
+    const aggregatedRuntimeImportDeclaration = ts.factory.createImportDeclaration(
+      void 0,
+      ts.factory.createImportClause(false, void 0, namedBindings),
+      ts.factory.createStringLiteral("relay-runtime")
+    );
+    const aggregatedRuntimeImportAST = ast.reduce(
+      (prev, curr) => {
+        if (!ts.isImportDeclaration(curr))
+          prev.push(curr);
+        return prev;
+      },
+      [aggregatedRuntimeImportDeclaration]
+    );
+    return aggregatedRuntimeImportAST;
+  } else {
+    return ast;
+  }
+}
+function nullThrows(obj) {
+  if (obj == null) {
+    throw new Error("Obj is null");
+  }
+  return obj;
+}
+function makeProp(schema, selection, state, unmasked, concreteType) {
+  let { value } = selection;
+  const { key, schemaName, conditional, nodeType, nodeSelections } = selection;
+  if (schemaName === "__typename" && concreteType) {
+    value = ts.factory.createLiteralTypeNode(
+      ts.factory.createStringLiteral(concreteType)
+    );
+  } else if (nodeType) {
+    value = transformScalarType(
+      schema,
+      nodeType,
+      state,
+      selectionsToAST(
+        schema,
+        [Array.from(nullThrows(nodeSelections).values())],
+        state,
+        unmasked
+      )
+    );
+  }
+  const typeProperty = objectTypeProperty(key, value, {
+    optional: conditional
+  });
+  return typeProperty;
+}
+var isTypenameSelection = (selection) => selection.schemaName === "__typename";
+var hasTypenameSelection = (selections) => selections.some(isTypenameSelection);
+var onlySelectsTypename = (selections) => selections.every(isTypenameSelection);
+function selectionsToAST(schema, selections, state, unmasked, fragmentTypeName) {
+  const baseFields = /* @__PURE__ */ new Map();
+  const byConcreteType = {};
+  flattenArray(selections).forEach((selection) => {
+    const { concreteType } = selection;
+    if (concreteType) {
+      byConcreteType[concreteType] = byConcreteType[concreteType] || [];
+      byConcreteType[concreteType].push(selection);
+    } else {
+      const previousSel = baseFields.get(selection.key);
+      baseFields.set(
+        selection.key,
+        previousSel ? mergeSelection(selection, previousSel) : selection
+      );
+    }
+  });
+  const types = [];
+  if (Object.keys(byConcreteType).length > 0 && onlySelectsTypename(Array.from(baseFields.values())) && (hasTypenameSelection(Array.from(baseFields.values())) || Object.keys(byConcreteType).every(
+    (type) => hasTypenameSelection(byConcreteType[type])
+  ))) {
+    const typenameAliases = /* @__PURE__ */ new Set();
+    for (const concreteType in byConcreteType) {
+      types.push(
+        groupRefs([
+          ...Array.from(baseFields.values()),
+          ...byConcreteType[concreteType]
+        ]).map((selection) => {
+          if (selection.schemaName === "__typename") {
+            typenameAliases.add(selection.key);
+          }
+          return makeProp(schema, selection, state, unmasked, concreteType);
+        })
+      );
+    }
+    types.push(
+      Array.from(typenameAliases).map((typenameAlias) => {
+        const otherProp = objectTypeProperty(
+          typenameAlias,
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("%other")
+          )
+        );
+        const otherPropWithComment = ts.addSyntheticLeadingComment(
+          otherProp,
+          ts.SyntaxKind.MultiLineCommentTrivia,
+          "This will never be '%other', but we need some\nvalue in case none of the concrete values match.",
+          true
+        );
+        return otherPropWithComment;
+      })
+    );
+  } else {
+    let selectionMap = selectionsToMap(Array.from(baseFields.values()));
+    for (const concreteType in byConcreteType) {
+      selectionMap = mergeSelections(
+        selectionMap,
+        selectionsToMap(
+          byConcreteType[concreteType].map((sel) => __spreadProps(__spreadValues({}, sel), {
+            conditional: true
+          }))
+        )
+      );
+    }
+    const selectionMapValues = groupRefs(Array.from(selectionMap.values())).map(
+      (sel) => isTypenameSelection(sel) && sel.concreteType ? makeProp(
+        schema,
+        __spreadProps(__spreadValues({}, sel), {
+          conditional: false
+        }),
+        state,
+        unmasked,
+        sel.concreteType
+      ) : makeProp(schema, sel, state, unmasked)
+    );
+    types.push(selectionMapValues);
+  }
+  const typeElements = types.map((props) => {
+    if (fragmentTypeName) {
+      props.push(
+        objectTypeProperty(
+          REF_TYPE,
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral(fragmentTypeName)
+          )
+        )
+      );
+    }
+    return unmasked ? ts.factory.createTypeLiteralNode(props) : exactObjectTypeAnnotation(props);
+  });
+  if (typeElements.length === 1) {
+    return typeElements[0];
+  }
+  return ts.factory.createUnionTypeNode(typeElements);
+}
+function exactObjectTypeAnnotation(properties) {
+  return ts.factory.createTypeLiteralNode(properties);
+}
+var idRegex = /^[$a-zA-Z_][$a-z0-9A-Z_]*$/;
+function createInexactOptionalType(type) {
+  if (ts.isUnionTypeNode(type)) {
+    return ts.factory.updateUnionTypeNode(
+      type,
+      ts.factory.createNodeArray([
+        ...type.types,
+        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+      ])
+    );
+  } else {
+    return ts.factory.createUnionTypeNode([
+      type,
+      ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+    ]);
+  }
+}
+function objectTypeProperty(propertyName, type, options = {}) {
+  const { optional, readonly = true } = options;
+  const modifiers = readonly ? [ts.factory.createToken(ts.SyntaxKind.ReadonlyKeyword)] : void 0;
+  return ts.factory.createPropertySignature(
+    modifiers,
+    idRegex.test(propertyName) ? ts.factory.createIdentifier(propertyName) : ts.factory.createStringLiteral(propertyName),
+    optional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0,
+    optional ? createInexactOptionalType(type) : type
+  );
+}
+function mergeSelection(a, b, shouldSetConditional = true) {
+  if (!a) {
+    if (shouldSetConditional) {
+      return __spreadProps(__spreadValues({}, b), {
+        conditional: true
+      });
+    }
+    return b;
+  }
+  return __spreadProps(__spreadValues({}, a), {
+    nodeSelections: a.nodeSelections ? mergeSelections(
+      a.nodeSelections,
+      nullThrows(b.nodeSelections),
+      shouldSetConditional
+    ) : null,
+    conditional: a.conditional && b.conditional
+  });
+}
+function mergeSelections(a, b, shouldSetConditional = true) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [key, value] of Array.from(a.entries())) {
+    merged.set(key, value);
+  }
+  for (const [key, value] of Array.from(b.entries())) {
+    merged.set(key, mergeSelection(a.get(key), value, shouldSetConditional));
+  }
+  return merged;
+}
+function isPlural(node) {
+  return Boolean(node.metadata && node.metadata.plural);
+}
+function exportType(name, type) {
+  return ts.factory.createTypeAliasDeclaration(
+    [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+    ts.factory.createIdentifier(name),
+    void 0,
+    type
+  );
+}
+function importTypes(names, fromModule) {
+  return names && ts.factory.createImportDeclaration(
+    void 0,
+    ts.factory.createImportClause(
+      false,
+      void 0,
+      ts.factory.createNamedImports(
+        names.map(
+          (name) => ts.factory.createImportSpecifier(
+            false,
+            void 0,
+            ts.factory.createIdentifier(name)
+          )
+        )
+      )
+    ),
+    ts.factory.createStringLiteral(fromModule)
+  );
+}
+function createVisitor(schema, options) {
+  const state = {
+    customScalars: options.customScalars,
+    enumsHasteModule: options.enumsHasteModule,
+    existingFragmentNames: options.existingFragmentNames,
+    generatedFragments: /* @__PURE__ */ new Set(),
+    generatedInputObjectTypes: {},
+    optionalInputFields: options.optionalInputFields,
+    usedEnums: {},
+    usedFragments: /* @__PURE__ */ new Set(),
+    useHaste: options.useHaste,
+    useSingleArtifactDirectory: options.useSingleArtifactDirectory,
+    noFutureProofEnums: options.noFutureProofEnums,
+    matchFields: /* @__PURE__ */ new Map(),
+    runtimeImports: /* @__PURE__ */ new Set()
+  };
+  return {
+    leave: {
+      Root(node) {
+        const inputVariablesType = generateInputVariablesType(
+          schema,
+          node,
+          state
+        );
+        const inputObjectTypes = generateInputObjectTypes(state);
+        const responseType = exportType(
+          `${node.name}Response`,
+          selectionsToAST(
+            schema,
+            /* $FlowFixMe: selections have already been transformed */
+            node.selections,
+            state,
+            false
+          )
+        );
+        const operationTypes = [
+          objectTypeProperty(
+            "response",
+            ts.factory.createTypeReferenceNode(responseType.name, void 0)
+          ),
+          objectTypeProperty(
+            "variables",
+            ts.factory.createTypeReferenceNode(
+              inputVariablesType.name,
+              void 0
+            )
+          )
+        ];
+        let rawResponseType;
+        const { normalizationIR } = options;
+        if (normalizationIR && node.directives.some((d) => d.name === DIRECTIVE_NAME)) {
+          rawResponseType = IRVisitor.visit(
+            normalizationIR,
+            createRawResponseTypeVisitor(schema, state)
+          );
+        }
+        const nodes = [];
+        if (state.runtimeImports.size) {
+          nodes.push(
+            importTypes(
+              Array.from(state.runtimeImports).sort(),
+              "relay-runtime"
+            )
+          );
+        }
+        nodes.push(
+          ...getFragmentRefsTypeImport(state),
+          ...getEnumDefinitions(schema, state),
+          ...inputObjectTypes,
+          inputVariablesType,
+          responseType
+        );
+        if (rawResponseType) {
+          for (const [key, ast] of state.matchFields) {
+            nodes.push(exportType(key, ast));
+          }
+          operationTypes.push(
+            objectTypeProperty(
+              "rawResponse",
+              ts.factory.createTypeReferenceNode(
+                `${node.name}RawResponse`,
+                void 0
+              )
+            )
+          );
+          nodes.push(rawResponseType);
+        }
+        nodes.push(
+          exportType(node.name, exactObjectTypeAnnotation(operationTypes))
+        );
+        return nodes;
+      },
+      Fragment(node) {
+        const flattenedSelections = flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        );
+        const numConcreteSelections = flattenedSelections.filter(
+          (s) => s.concreteType
+        ).length;
+        const selections = flattenedSelections.map((selection) => {
+          if (numConcreteSelections <= 1 && isTypenameSelection(selection) && !schema.isAbstractType(node.type)) {
+            return [
+              __spreadProps(__spreadValues({}, selection), {
+                concreteType: schema.getTypeString(node.type)
+              })
+            ];
+          }
+          return [selection];
+        });
+        state.generatedFragments.add(node.name);
+        const dataTypeName = getDataTypeName(node.name);
+        const dataType = ts.factory.createTypeReferenceNode(
+          node.name,
+          void 0
+        );
+        const refTypeName = getRefTypeName(node.name);
+        const refTypeDataProperty = objectTypeProperty(
+          DATA_REF,
+          ts.factory.createTypeReferenceNode(dataTypeName, void 0),
+          { optional: true }
+        );
+        const refTypeFragmentRefProperty = objectTypeProperty(
+          FRAGMENT_REFS,
+          ts.factory.createTypeReferenceNode(FRAGMENT_REFS_TYPE_NAME, [
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral(node.name)
+            )
+          ])
+        );
+        const isPluralFragment = isPlural(node);
+        const refType = exactObjectTypeAnnotation([
+          refTypeDataProperty,
+          refTypeFragmentRefProperty
+        ]);
+        const unmasked = node.metadata != null && node.metadata.mask === false;
+        const baseType = selectionsToAST(
+          schema,
+          selections,
+          state,
+          unmasked,
+          unmasked ? void 0 : node.name
+        );
+        const type = isPlural(node) ? ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier("ReadonlyArray"),
+          [baseType]
+        ) : baseType;
+        state.runtimeImports.add("FragmentRefs");
+        return [
+          importTypes(Array.from(state.runtimeImports).sort(), "relay-runtime"),
+          ...getEnumDefinitions(schema, state),
+          exportType(node.name, type),
+          exportType(dataTypeName, dataType),
+          exportType(
+            refTypeName,
+            isPluralFragment ? ts.factory.createTypeReferenceNode(
+              ts.factory.createIdentifier("ReadonlyArray"),
+              [refType]
+            ) : refType
+          )
+        ];
+      },
+      InlineFragment(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        ).map((typeSelection) => {
+          return schema.isAbstractType(node.typeCondition) ? __spreadProps(__spreadValues({}, typeSelection), {
+            conditional: true
+          }) : __spreadProps(__spreadValues({}, typeSelection), {
+            concreteType: schema.getTypeString(node.typeCondition)
+          });
+        });
+      },
+      Condition(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        ).map((selection) => {
+          return __spreadProps(__spreadValues({}, selection), {
+            conditional: true
+          });
+        });
+      },
+      // TODO: Why not inline it like others?
+      ScalarField(node) {
+        return visitScalarField(schema, node, state);
+      },
+      LinkedField: visitLinkedField,
+      ModuleImport(node) {
+        return [
+          {
+            key: "__fragmentPropName",
+            conditional: true,
+            value: transformScalarType(
+              schema,
+              schema.expectStringType(),
+              state
+            )
+          },
+          {
+            key: "__module_component",
+            conditional: true,
+            value: transformScalarType(
+              schema,
+              schema.expectStringType(),
+              state
+            )
+          },
+          {
+            key: "__fragments_" + node.name,
+            ref: node.name
+          }
+        ];
+      },
+      FragmentSpread(node) {
+        state.usedFragments.add(node.name);
+        return [
+          {
+            key: "__fragments_" + node.name,
+            ref: node.name
+          }
+        ];
+      }
+    }
+  };
+}
+function visitScalarField(schema, node, state) {
+  return [
+    {
+      key: node.alias || node.name,
+      schemaName: node.name,
+      value: transformScalarType(schema, node.type, state)
+    }
+  ];
+}
+function visitLinkedField(node) {
+  return [
+    {
+      key: node.alias || node.name,
+      schemaName: node.name,
+      nodeType: node.type,
+      nodeSelections: selectionsToMap(
+        flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        ),
+        /*
+         * append concreteType to key so overlapping fields with different
+         * concreteTypes don't get overwritten by each other
+         */
+        true
+      )
+    }
+  ];
+}
+function makeRawResponseProp(schema, {
+  key,
+  schemaName,
+  value,
+  conditional,
+  nodeType,
+  nodeSelections,
+  kind
+}, state, concreteType) {
+  if (kind === "ModuleImport") {
+    throw new Error(
+      "relay-compiler-language-typescript does not support @module yet"
+    );
+  }
+  if (schemaName === "__typename" && concreteType) {
+    value = ts.factory.createLiteralTypeNode(
+      ts.factory.createStringLiteral(concreteType)
+    );
+  } else if (nodeType) {
+    value = transformScalarType(
+      schema,
+      nodeType,
+      state,
+      selectionsToRawResponseBabel(
+        schema,
+        [Array.from(nullThrows(nodeSelections).values())],
+        state,
+        schema.isAbstractType(nodeType) || schema.isWrapper(nodeType) ? null : schema.getTypeString(nodeType)
+      )
+    );
+  }
+  const typeProperty = objectTypeProperty(key, value, {
+    optional: conditional
+  });
+  return typeProperty;
+}
+function selectionsToMap(selections, appendType) {
+  const map = /* @__PURE__ */ new Map();
+  selections.forEach((selection) => {
+    const key = appendType && selection.concreteType ? `${selection.key}::${selection.concreteType}` : selection.key;
+    const previousSel = map.get(key);
+    map.set(
+      key,
+      previousSel ? mergeSelection(previousSel, selection) : selection
+    );
+  });
+  return map;
+}
+function selectionsToRawResponseBabel(schema, selections, state, nodeTypeName) {
+  const baseFields = [];
+  const byConcreteType = {};
+  flattenArray(selections).forEach((selection) => {
+    const { concreteType } = selection;
+    if (concreteType) {
+      byConcreteType[concreteType] = byConcreteType[concreteType] || [];
+      byConcreteType[concreteType].push(selection);
+    } else {
+      baseFields.push(selection);
+    }
+  });
+  const types = [];
+  if (Object.keys(byConcreteType).length) {
+    const baseFieldsMap = selectionsToMap(baseFields);
+    for (const concreteType in byConcreteType) {
+      const mergedSelections = Array.from(
+        mergeSelections(
+          baseFieldsMap,
+          selectionsToMap(byConcreteType[concreteType]),
+          false
+        ).values()
+      );
+      types.push(
+        exactObjectTypeAnnotation(
+          mergedSelections.map(
+            (selection) => makeRawResponseProp(schema, selection, state, concreteType)
+          )
+        )
+      );
+      appendLocal3DPayload(
+        types,
+        mergedSelections,
+        schema,
+        state,
+        concreteType
+      );
+    }
+  }
+  if (baseFields.length > 0) {
+    types.push(
+      exactObjectTypeAnnotation(
+        baseFields.map(
+          (selection) => makeRawResponseProp(schema, selection, state, nodeTypeName)
+        )
+      )
+    );
+    appendLocal3DPayload(types, baseFields, schema, state, nodeTypeName);
+  }
+  return ts.factory.createUnionTypeNode(types);
+}
+function appendLocal3DPayload(types, selections, schema, state, currentType) {
+  const moduleImport = selections.find((sel) => sel.kind === "ModuleImport");
+  if (moduleImport) {
+    state.runtimeImports.add("Local3DPayload");
+    types.push(
+      ts.factory.createTypeReferenceNode(
+        ts.factory.createIdentifier("Local3DPayload"),
+        [
+          stringLiteralTypeAnnotation(moduleImport.documentName),
+          exactObjectTypeAnnotation(
+            selections.filter((sel) => sel.schemaName !== "js").map(
+              (selection) => makeRawResponseProp(schema, selection, state, currentType)
+            )
+          )
+        ]
+      )
+    );
+  }
+}
+function createRawResponseTypeVisitor(schema, state) {
+  return {
+    leave: {
+      Root(node) {
+        return exportType(
+          `${node.name}RawResponse`,
+          selectionsToRawResponseBabel(
+            schema,
+            /* $FlowFixMe: selections have already been transformed */
+            node.selections,
+            state,
+            null
+          )
+        );
+      },
+      InlineFragment(node) {
+        const typeCondition = node.typeCondition;
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        ).map((typeSelection) => {
+          return schema.isAbstractType(typeCondition) ? typeSelection : __spreadProps(__spreadValues({}, typeSelection), {
+            concreteType: schema.getTypeString(typeCondition)
+          });
+        });
+      },
+      ScalarField(node) {
+        return visitScalarField(schema, node, state);
+      },
+      ClientExtension(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        ).map((sel) => __spreadProps(__spreadValues({}, sel), {
+          conditional: true
+        }));
+      },
+      LinkedField: visitLinkedField,
+      Condition(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        );
+      },
+      Defer(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        );
+      },
+      Stream(node) {
+        return flattenArray(
+          /* $FlowFixMe: selections have already been transformed */
+          node.selections
+        );
+      },
+      ModuleImport(node) {
+        return visitRawResponseModuleImport(schema, node, state);
+      },
+      FragmentSpread(_node) {
+        throw new Error(
+          "A fragment spread is found when traversing the AST, make sure you are passing the codegen IR"
+        );
+      }
+    }
+  };
+}
+function visitRawResponseModuleImport(schema, node, state) {
+  const { selections, name: key } = node;
+  const moduleSelections = selections.filter((sel) => sel.length && sel[0].schemaName === "js").map((arr) => arr[0]);
+  if (!state.matchFields.has(key)) {
+    const ast = selectionsToRawResponseBabel(
+      schema,
+      node.selections.filter(
+        (sel) => sel.length > 1 || sel[0].schemaName !== "js"
+      ),
+      state,
+      null
+    );
+    state.matchFields.set(key, ast);
+  }
+  return [
+    ...moduleSelections,
+    {
+      key,
+      kind: "ModuleImport",
+      documentName: node.documentName
+    }
+  ];
+}
+function flattenArray(arrayOfArrays) {
+  const result = [];
+  arrayOfArrays.forEach((array) => result.push(...array));
+  return result;
+}
+function generateInputObjectTypes(state) {
+  return Object.keys(state.generatedInputObjectTypes).map((typeIdentifier) => {
+    const inputObjectType = state.generatedInputObjectTypes[typeIdentifier];
+    if (inputObjectType === "pending") {
+      throw new Error(
+        "TypeScriptGenerator: Expected input object type to have been defined before calling `generateInputObjectTypes`"
+      );
+    } else {
+      return exportType(typeIdentifier, inputObjectType);
+    }
+  });
+}
+function generateInputVariablesType(schema, node, state) {
+  return exportType(
+    `${node.name}Variables`,
+    exactObjectTypeAnnotation(
+      node.argumentDefinitions.map((arg) => {
+        return objectTypeProperty(
+          arg.name,
+          transformInputType(schema, arg.type, state),
+          { readonly: false, optional: !schema.isNonNull(arg.type) }
+        );
+      })
+    )
+  );
+}
+function groupRefs(props) {
+  const result = [];
+  const refs = [];
+  props.forEach((prop) => {
+    if (prop.ref) {
+      refs.push(prop.ref);
+    } else {
+      result.push(prop);
+    }
+  });
+  if (refs.length > 0) {
+    const refTypes = ts.factory.createUnionTypeNode(
+      refs.map(
+        (ref) => ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(ref))
+      )
+    );
+    result.push({
+      key: FRAGMENT_REFS,
+      conditional: false,
+      value: ts.factory.createTypeReferenceNode(FRAGMENT_REFS_TYPE_NAME, [
+        refTypes
+      ])
+    });
+  }
+  return result;
+}
+function getFragmentRefsTypeImport(state) {
+  if (state.usedFragments.size > 0) {
+    return [
+      ts.factory.createImportDeclaration(
+        void 0,
+        ts.factory.createImportClause(
+          false,
+          void 0,
+          ts.factory.createNamedImports([
+            ts.factory.createImportSpecifier(
+              false,
+              void 0,
+              ts.factory.createIdentifier("FragmentRefs")
+            )
+          ])
+        ),
+        ts.factory.createStringLiteral("relay-runtime")
+      )
+    ];
+  }
+  return [];
+}
+function getEnumDefinitions(schema, { enumsHasteModule, usedEnums, noFutureProofEnums }) {
+  const enumNames = Object.keys(usedEnums).sort();
+  if (enumNames.length === 0) {
+    return [];
+  }
+  if (typeof enumsHasteModule === "string") {
+    return [importTypes(enumNames, enumsHasteModule)];
+  }
+  if (typeof enumsHasteModule === "function") {
+    return enumNames.map(
+      (enumName) => importTypes([enumName], enumsHasteModule(enumName))
+    );
+  }
+  return enumNames.map((name) => {
+    const values = [...schema.getEnumValues(usedEnums[name])];
+    values.sort();
+    if (!noFutureProofEnums) {
+      values.push("%future added value");
+    }
+    return exportType(
+      name,
+      ts.factory.createUnionTypeNode(
+        values.map((value) => stringLiteralTypeAnnotation(value))
+      )
+    );
+  });
+}
+function stringLiteralTypeAnnotation(name) {
+  return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(name));
+}
+function getRefTypeName(name) {
+  return `${name}$key`;
+}
+function getDataTypeName(name) {
+  return `${name}$data`;
+}
+var transforms = [
+  RelayDirectiveTransform.transform,
+  MaskTransform.transform,
+  MatchTransform.transform,
+  FlattenTransform.transformWithOptions({}),
+  RefetchableFragmentTransform.transform
+];
+export {
+  generate,
+  transforms
+};