@graphitation/apollo-react-relay-duct-tape-compiler 1.0.0-alpha.1

package/lib/compilerTransforms/annotateFragmentReferenceTransform.mjs

@@ -0,0 +1,82 @@
+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/compilerTransforms/annotateFragmentReferenceTransform.ts
+import { visit } from "relay-compiler/lib/core/IRVisitor";
+import { implementsNodeInterface } from "./utils.mjs";
+var FRAGMENTS_SELECTION = {
+  kind: "ScalarField",
+  name: "__fragments",
+  alias: "__fragments",
+  type: "String!",
+  directives: [
+    {
+      kind: "Directive",
+      name: "client",
+      args: [],
+      loc: { kind: "Generated" },
+      metadata: void 0
+    }
+  ],
+  args: [],
+  loc: { kind: "Generated" },
+  metadata: void 0
+};
+var FRAGMENTS_ON_NODE_SELECTION = {
+  kind: "InlineFragment",
+  typeCondition: "Node",
+  selections: [FRAGMENTS_SELECTION],
+  directives: [],
+  loc: { kind: "Generated" },
+  metadata: void 0
+};
+var annotateFragmentReferenceTransform = (context) => {
+  const visitor = visitNodeWithSelections.bind(null, context);
+  let nextContext = context;
+  context.forEachDocument((document) => {
+    const nextDocument = visit(document, {
+      Root: visitor,
+      Fragment: visitor,
+      InlineFragment: visitor,
+      LinkedField: visitor
+    });
+    nextContext = nextContext.replace(nextDocument);
+  });
+  return nextContext;
+};
+function visitNodeWithSelections(context, node) {
+  for (const selection of node.selections) {
+    if (selection.kind === "FragmentSpread") {
+      const fragment = context.getFragment(selection.name);
+      if (implementsNodeInterface(context, fragment)) {
+        return __spreadProps(__spreadValues({}, node), {
+          selections: [...node.selections, FRAGMENTS_ON_NODE_SELECTION]
+        });
+      } else if (fragment.type === context.getSchema().getQueryType()) {
+        return __spreadProps(__spreadValues({}, node), {
+          selections: [...node.selections, FRAGMENTS_SELECTION]
+        });
+      }
+    }
+  }
+}
+export {
+  annotateFragmentReferenceTransform
+};

package/lib/compilerTransforms/annotateFragmentReferenceTransform.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/compilerTransforms/annotateFragmentReferenceTransform.ts"],
+  "sourcesContent": ["import {\n  CompilerContext,\n  Fragment,\n  InlineFragment,\n  LinkedField,\n  Root,\n  ScalarField,\n} from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { visit } from \"relay-compiler/lib/core/IRVisitor\";\nimport { implementsNodeInterface } from \"./utils\";\n\nconst FRAGMENTS_SELECTION: ScalarField = {\n  kind: \"ScalarField\",\n  name: \"__fragments\",\n  alias: \"__fragments\",\n  type: \"String!\",\n  directives: [\n    {\n      kind: \"Directive\",\n      name: \"client\",\n      args: [],\n      loc: { kind: \"Generated\" },\n      metadata: undefined,\n    },\n  ],\n  args: [],\n  loc: { kind: \"Generated\" },\n  metadata: undefined,\n};\n\nconst FRAGMENTS_ON_NODE_SELECTION: InlineFragment = {\n  kind: \"InlineFragment\",\n  typeCondition: \"Node\",\n  selections: [FRAGMENTS_SELECTION],\n  directives: [],\n  loc: { kind: \"Generated\" },\n  metadata: undefined,\n};\n\n/**\n * Inserts a `__fragments` selection at the place where a fragment reference\n * boundary exists. This is either done in a `Node` inline fragment or directly\n * on the `Query` type.\n *\n * This field, which is an Apollo Client client-side field as declared with the\n * `@client` directive, will be used to pass context between the `use*Fragment`\n * hooks. (Currently this is limited to request variables.) The data for this\n * field is resolved by the `fragmentReferencesFieldPolicy` function.\n */\nexport const annotateFragmentReferenceTransform: IRTransform = (context) => {\n  const visitor = visitNodeWithSelections.bind(null, context);\n  let nextContext = context;\n\n  context.forEachDocument((document) => {\n    const nextDocument = visit(document, {\n      Root: visitor,\n      Fragment: visitor,\n      InlineFragment: visitor,\n      LinkedField: visitor,\n    });\n    nextContext = nextContext.replace(nextDocument);\n  });\n\n  return nextContext;\n};\n\nfunction visitNodeWithSelections(\n  context: CompilerContext,\n  node: Root | Fragment | InlineFragment | LinkedField\n): Root | Fragment | InlineFragment | LinkedField | undefined {\n  for (const selection of node.selections) {\n    if (selection.kind === \"FragmentSpread\") {\n      const fragment = context.getFragment(selection.name);\n      if (implementsNodeInterface(context, fragment)) {\n        return {\n          ...node,\n          selections: [...node.selections, FRAGMENTS_ON_NODE_SELECTION],\n        };\n      } else if (fragment.type === context.getSchema().getQueryType()) {\n        return {\n          ...node,\n          selections: [...node.selections, FRAGMENTS_SELECTION],\n        };\n      }\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AASA,SAAS,aAAa;AACtB,SAAS,+BAA+B;AAExC,IAAM,sBAAmC;AAAA,EACvC,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,MAAM;AAAA,EACN,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM,CAAC;AAAA,MACP,KAAK,EAAE,MAAM,YAAY;AAAA,MACzB,UAAU;AAAA,IACZ;AAAA,EACF;AAAA,EACA,MAAM,CAAC;AAAA,EACP,KAAK,EAAE,MAAM,YAAY;AAAA,EACzB,UAAU;AACZ;AAEA,IAAM,8BAA8C;AAAA,EAClD,MAAM;AAAA,EACN,eAAe;AAAA,EACf,YAAY,CAAC,mBAAmB;AAAA,EAChC,YAAY,CAAC;AAAA,EACb,KAAK,EAAE,MAAM,YAAY;AAAA,EACzB,UAAU;AACZ;AAYO,IAAM,qCAAkD,CAAC,YAAY;AAC1E,QAAM,UAAU,wBAAwB,KAAK,MAAM,OAAO;AAC1D,MAAI,cAAc;AAElB,UAAQ,gBAAgB,CAAC,aAAa;AACpC,UAAM,eAAe,MAAM,UAAU;AAAA,MACnC,MAAM;AAAA,MACN,UAAU;AAAA,MACV,gBAAgB;AAAA,MAChB,aAAa;AAAA,IACf,CAAC;AACD,kBAAc,YAAY,QAAQ,YAAY;AAAA,EAChD,CAAC;AAED,SAAO;AACT;AAEA,SAAS,wBACP,SACA,MAC4D;AAC5D,aAAW,aAAa,KAAK,YAAY;AACvC,QAAI,UAAU,SAAS,kBAAkB;AACvC,YAAM,WAAW,QAAQ,YAAY,UAAU,IAAI;AACnD,UAAI,wBAAwB,SAAS,QAAQ,GAAG;AAC9C,eAAO,iCACF,OADE;AAAA,UAEL,YAAY,CAAC,GAAG,KAAK,YAAY,2BAA2B;AAAA,QAC9D;AAAA,MACF,WAAW,SAAS,SAAS,QAAQ,UAAU,EAAE,aAAa,GAAG;AAC/D,eAAO,iCACF,OADE;AAAA,UAEL,YAAY,CAAC,GAAG,KAAK,YAAY,mBAAmB;AAAA,QACtD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/lib/compilerTransforms/emitApolloClientConnectionTransform.d.ts

@@ -0,0 +1,12 @@
+import { IRTransform } from "relay-compiler/lib/core/CompilerContext";
+/**
+ * Finds connection client-handles that relay-compiler emits and replaces
+ * them with a version of the `@connection` directive that Apollo Client uses;
+ * which is identical to relay's version, except the `filters` parameter is
+ * named `filter` (singular).
+ *
+ * @param wrappedConnectionTransform
+ *   relay-compiler's connection client-handle transform
+ */
+export declare function emitApolloClientConnectionTransform(wrappedConnectionTransform: IRTransform): IRTransform;
+//# sourceMappingURL=emitApolloClientConnectionTransform.d.ts.map

package/lib/compilerTransforms/emitApolloClientConnectionTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitApolloClientConnectionTransform.d.ts","sourceRoot":"","sources":["../../src/compilerTransforms/emitApolloClientConnectionTransform.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAMtE;;;;;;;;GAQG;AACH,wBAAgB,mCAAmC,CACjD,0BAA0B,EAAE,WAAW,GACtC,WAAW,CA6Eb"}

package/lib/compilerTransforms/emitApolloClientConnectionTransform.js

@@ -0,0 +1,116 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var emitApolloClientConnectionTransform_exports = {};
+__export(emitApolloClientConnectionTransform_exports, {
+  emitApolloClientConnectionTransform: () => emitApolloClientConnectionTransform
+});
+module.exports = __toCommonJS(emitApolloClientConnectionTransform_exports);
+var import_IRVisitor = require("relay-compiler/lib/core/IRVisitor");
+const SchemaUtils = require("relay-compiler/lib/core/SchemaUtils");
+function emitApolloClientConnectionTransform(wrappedConnectionTransform) {
+  const connectionTransformWrapper = (context) => {
+    const schema = context.getSchema();
+    let nextContext = wrappedConnectionTransform(context);
+    nextContext.forEachDocument((document) => {
+      const nextDocument = (0, import_IRVisitor.visit)(document, {
+        LinkedField(linkedFieldNode) {
+          var _a, _b;
+          const connectionHandle = (_a = linkedFieldNode.handles) == null ? void 0 : _a.find(
+            (handle) => handle.name === "connection"
+          );
+          if (connectionHandle) {
+            const args = [
+              {
+                kind: "Argument",
+                name: "key",
+                type: SchemaUtils.getNonNullStringInput(schema),
+                value: {
+                  kind: "Literal",
+                  value: connectionHandle.key,
+                  loc: { kind: "Generated" }
+                },
+                loc: { kind: "Generated" },
+                metadata: void 0
+              }
+            ];
+            if (connectionHandle.filters) {
+              args.push({
+                kind: "Argument",
+                name: "filter",
+                type: schema.assertInputType(
+                  schema.expectTypeFromString("[String!]")
+                ),
+                value: {
+                  kind: "ListValue",
+                  items: connectionHandle.filters.map(
+                    (filter) => ({
+                      kind: "Literal",
+                      value: filter,
+                      loc: { kind: "Generated" }
+                    })
+                  ),
+                  loc: { kind: "Generated" },
+                  metadata: void 0
+                },
+                loc: { kind: "Generated" },
+                metadata: void 0
+              });
+            }
+            const nextLinkedFieldNode = __spreadProps(__spreadValues({}, linkedFieldNode), {
+              handles: (_b = linkedFieldNode.handles) == null ? void 0 : _b.filter(
+                (handle) => handle.name !== "connection"
+              ),
+              directives: [
+                ...linkedFieldNode.directives,
+                {
+                  kind: "Directive",
+                  name: "connection",
+                  args,
+                  loc: { kind: "Generated" },
+                  metadata: void 0
+                }
+              ]
+            });
+            return nextLinkedFieldNode;
+          }
+        }
+      });
+      nextContext = nextContext.replace(nextDocument);
+    });
+    return nextContext;
+  };
+  return connectionTransformWrapper;
+}

package/lib/compilerTransforms/emitApolloClientConnectionTransform.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/compilerTransforms/emitApolloClientConnectionTransform.ts"],
+  "sourcesContent": ["import invariant from \"invariant\";\nimport { Argument, ArgumentValue, LinkedField } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { visit } from \"relay-compiler/lib/core/IRVisitor\";\n\n// TODO: Add typings for this\nconst SchemaUtils = require(\"relay-compiler/lib/core/SchemaUtils\");\n\n/**\n * Finds connection client-handles that relay-compiler emits and replaces\n * them with a version of the `@connection` directive that Apollo Client uses;\n * which is identical to relay's version, except the `filters` parameter is\n * named `filter` (singular).\n *\n * @param wrappedConnectionTransform\n *   relay-compiler's connection client-handle transform\n */\nexport function emitApolloClientConnectionTransform(\n  wrappedConnectionTransform: IRTransform,\n): IRTransform {\n  const connectionTransformWrapper: IRTransform = (context) => {\n    const schema = context.getSchema();\n    let nextContext = wrappedConnectionTransform(context);\n\n    // Replaces the field handle created by the wrapped connection transform\n    // with the @connection directive that Apollo Client expects\n    nextContext.forEachDocument((document) => {\n      const nextDocument = visit(document, {\n        LinkedField(linkedFieldNode) {\n          const connectionHandle = linkedFieldNode.handles?.find(\n            (handle) => handle.name === \"connection\",\n          );\n          if (connectionHandle) {\n            const args: Argument[] = [\n              {\n                kind: \"Argument\",\n                name: \"key\",\n                type: SchemaUtils.getNonNullStringInput(schema),\n                value: {\n                  kind: \"Literal\",\n                  value: connectionHandle.key,\n                  loc: { kind: \"Generated\" },\n                },\n                loc: { kind: \"Generated\" },\n                metadata: undefined,\n              },\n            ];\n            if (connectionHandle.filters) {\n              args.push({\n                kind: \"Argument\",\n                name: \"filter\",\n                type: schema.assertInputType(\n                  schema.expectTypeFromString(\"[String!]\"),\n                ),\n                value: {\n                  kind: \"ListValue\",\n                  items: connectionHandle.filters.map<ArgumentValue>(\n                    (filter) => ({\n                      kind: \"Literal\",\n                      value: filter,\n                      loc: { kind: \"Generated\" },\n                    }),\n                  ),\n                  loc: { kind: \"Generated\" },\n                  metadata: undefined,\n                },\n                loc: { kind: \"Generated\" },\n                metadata: undefined,\n              });\n            }\n            const nextLinkedFieldNode: LinkedField = {\n              ...linkedFieldNode,\n              handles: linkedFieldNode.handles?.filter(\n                (handle) => handle.name !== \"connection\",\n              ),\n              directives: [\n                ...linkedFieldNode.directives,\n                {\n                  kind: \"Directive\",\n                  name: \"connection\",\n                  args,\n                  loc: { kind: \"Generated\" },\n                  metadata: undefined,\n                },\n              ],\n            };\n            return nextLinkedFieldNode;\n          }\n        },\n      });\n      nextContext = nextContext.replace(nextDocument);\n    });\n\n    return nextContext;\n  };\n  return connectionTransformWrapper;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,uBAAsB;AAGtB,MAAM,cAAc,QAAQ,qCAAqC;AAW1D,SAAS,oCACd,4BACa;AACb,QAAM,6BAA0C,CAAC,YAAY;AAC3D,UAAM,SAAS,QAAQ,UAAU;AACjC,QAAI,cAAc,2BAA2B,OAAO;AAIpD,gBAAY,gBAAgB,CAAC,aAAa;AACxC,YAAM,mBAAe,wBAAM,UAAU;AAAA,QACnC,YAAY,iBAAiB;AA5BrC;AA6BU,gBAAM,oBAAmB,qBAAgB,YAAhB,mBAAyB;AAAA,YAChD,CAAC,WAAW,OAAO,SAAS;AAAA;AAE9B,cAAI,kBAAkB;AACpB,kBAAM,OAAmB;AAAA,cACvB;AAAA,gBACE,MAAM;AAAA,gBACN,MAAM;AAAA,gBACN,MAAM,YAAY,sBAAsB,MAAM;AAAA,gBAC9C,OAAO;AAAA,kBACL,MAAM;AAAA,kBACN,OAAO,iBAAiB;AAAA,kBACxB,KAAK,EAAE,MAAM,YAAY;AAAA,gBAC3B;AAAA,gBACA,KAAK,EAAE,MAAM,YAAY;AAAA,gBACzB,UAAU;AAAA,cACZ;AAAA,YACF;AACA,gBAAI,iBAAiB,SAAS;AAC5B,mBAAK,KAAK;AAAA,gBACR,MAAM;AAAA,gBACN,MAAM;AAAA,gBACN,MAAM,OAAO;AAAA,kBACX,OAAO,qBAAqB,WAAW;AAAA,gBACzC;AAAA,gBACA,OAAO;AAAA,kBACL,MAAM;AAAA,kBACN,OAAO,iBAAiB,QAAQ;AAAA,oBAC9B,CAAC,YAAY;AAAA,sBACX,MAAM;AAAA,sBACN,OAAO;AAAA,sBACP,KAAK,EAAE,MAAM,YAAY;AAAA,oBAC3B;AAAA,kBACF;AAAA,kBACA,KAAK,EAAE,MAAM,YAAY;AAAA,kBACzB,UAAU;AAAA,gBACZ;AAAA,gBACA,KAAK,EAAE,MAAM,YAAY;AAAA,gBACzB,UAAU;AAAA,cACZ,CAAC;AAAA,YACH;AACA,kBAAM,sBAAmC,iCACpC,kBADoC;AAAA,cAEvC,UAAS,qBAAgB,YAAhB,mBAAyB;AAAA,gBAChC,CAAC,WAAW,OAAO,SAAS;AAAA;AAAA,cAE9B,YAAY;AAAA,gBACV,GAAG,gBAAgB;AAAA,gBACnB;AAAA,kBACE,MAAM;AAAA,kBACN,MAAM;AAAA,kBACN;AAAA,kBACA,KAAK,EAAE,MAAM,YAAY;AAAA,kBACzB,UAAU;AAAA,gBACZ;AAAA,cACF;AAAA,YACF;AACA,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF,CAAC;AACD,oBAAc,YAAY,QAAQ,YAAY;AAAA,IAChD,CAAC;AAED,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/compilerTransforms/emitApolloClientConnectionTransform.mjs

@@ -0,0 +1,107 @@
+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));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/compilerTransforms/emitApolloClientConnectionTransform.ts
+import { visit } from "relay-compiler/lib/core/IRVisitor";
+var SchemaUtils = __require("relay-compiler/lib/core/SchemaUtils");
+function emitApolloClientConnectionTransform(wrappedConnectionTransform) {
+  const connectionTransformWrapper = (context) => {
+    const schema = context.getSchema();
+    let nextContext = wrappedConnectionTransform(context);
+    nextContext.forEachDocument((document) => {
+      const nextDocument = visit(document, {
+        LinkedField(linkedFieldNode) {
+          var _a, _b;
+          const connectionHandle = (_a = linkedFieldNode.handles) == null ? void 0 : _a.find(
+            (handle) => handle.name === "connection"
+          );
+          if (connectionHandle) {
+            const args = [
+              {
+                kind: "Argument",
+                name: "key",
+                type: SchemaUtils.getNonNullStringInput(schema),
+                value: {
+                  kind: "Literal",
+                  value: connectionHandle.key,
+                  loc: { kind: "Generated" }
+                },
+                loc: { kind: "Generated" },
+                metadata: void 0
+              }
+            ];
+            if (connectionHandle.filters) {
+              args.push({
+                kind: "Argument",
+                name: "filter",
+                type: schema.assertInputType(
+                  schema.expectTypeFromString("[String!]")
+                ),
+                value: {
+                  kind: "ListValue",
+                  items: connectionHandle.filters.map(
+                    (filter) => ({
+                      kind: "Literal",
+                      value: filter,
+                      loc: { kind: "Generated" }
+                    })
+                  ),
+                  loc: { kind: "Generated" },
+                  metadata: void 0
+                },
+                loc: { kind: "Generated" },
+                metadata: void 0
+              });
+            }
+            const nextLinkedFieldNode = __spreadProps(__spreadValues({}, linkedFieldNode), {
+              handles: (_b = linkedFieldNode.handles) == null ? void 0 : _b.filter(
+                (handle) => handle.name !== "connection"
+              ),
+              directives: [
+                ...linkedFieldNode.directives,
+                {
+                  kind: "Directive",
+                  name: "connection",
+                  args,
+                  loc: { kind: "Generated" },
+                  metadata: void 0
+                }
+              ]
+            });
+            return nextLinkedFieldNode;
+          }
+        }
+      });
+      nextContext = nextContext.replace(nextDocument);
+    });
+    return nextContext;
+  };
+  return connectionTransformWrapper;
+}
+export {
+  emitApolloClientConnectionTransform
+};

package/lib/compilerTransforms/emitApolloClientConnectionTransform.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/compilerTransforms/emitApolloClientConnectionTransform.ts"],
+  "sourcesContent": ["import invariant from \"invariant\";\nimport { Argument, ArgumentValue, LinkedField } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { visit } from \"relay-compiler/lib/core/IRVisitor\";\n\n// TODO: Add typings for this\nconst SchemaUtils = require(\"relay-compiler/lib/core/SchemaUtils\");\n\n/**\n * Finds connection client-handles that relay-compiler emits and replaces\n * them with a version of the `@connection` directive that Apollo Client uses;\n * which is identical to relay's version, except the `filters` parameter is\n * named `filter` (singular).\n *\n * @param wrappedConnectionTransform\n *   relay-compiler's connection client-handle transform\n */\nexport function emitApolloClientConnectionTransform(\n  wrappedConnectionTransform: IRTransform,\n): IRTransform {\n  const connectionTransformWrapper: IRTransform = (context) => {\n    const schema = context.getSchema();\n    let nextContext = wrappedConnectionTransform(context);\n\n    // Replaces the field handle created by the wrapped connection transform\n    // with the @connection directive that Apollo Client expects\n    nextContext.forEachDocument((document) => {\n      const nextDocument = visit(document, {\n        LinkedField(linkedFieldNode) {\n          const connectionHandle = linkedFieldNode.handles?.find(\n            (handle) => handle.name === \"connection\",\n          );\n          if (connectionHandle) {\n            const args: Argument[] = [\n              {\n                kind: \"Argument\",\n                name: \"key\",\n                type: SchemaUtils.getNonNullStringInput(schema),\n                value: {\n                  kind: \"Literal\",\n                  value: connectionHandle.key,\n                  loc: { kind: \"Generated\" },\n                },\n                loc: { kind: \"Generated\" },\n                metadata: undefined,\n              },\n            ];\n            if (connectionHandle.filters) {\n              args.push({\n                kind: \"Argument\",\n                name: \"filter\",\n                type: schema.assertInputType(\n                  schema.expectTypeFromString(\"[String!]\"),\n                ),\n                value: {\n                  kind: \"ListValue\",\n                  items: connectionHandle.filters.map<ArgumentValue>(\n                    (filter) => ({\n                      kind: \"Literal\",\n                      value: filter,\n                      loc: { kind: \"Generated\" },\n                    }),\n                  ),\n                  loc: { kind: \"Generated\" },\n                  metadata: undefined,\n                },\n                loc: { kind: \"Generated\" },\n                metadata: undefined,\n              });\n            }\n            const nextLinkedFieldNode: LinkedField = {\n              ...linkedFieldNode,\n              handles: linkedFieldNode.handles?.filter(\n                (handle) => handle.name !== \"connection\",\n              ),\n              directives: [\n                ...linkedFieldNode.directives,\n                {\n                  kind: \"Directive\",\n                  name: \"connection\",\n                  args,\n                  loc: { kind: \"Generated\" },\n                  metadata: undefined,\n                },\n              ],\n            };\n            return nextLinkedFieldNode;\n          }\n        },\n      });\n      nextContext = nextContext.replace(nextDocument);\n    });\n\n    return nextContext;\n  };\n  return connectionTransformWrapper;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,SAAS,aAAa;AAGtB,IAAM,cAAc,UAAQ,qCAAqC;AAW1D,SAAS,oCACd,4BACa;AACb,QAAM,6BAA0C,CAAC,YAAY;AAC3D,UAAM,SAAS,QAAQ,UAAU;AACjC,QAAI,cAAc,2BAA2B,OAAO;AAIpD,gBAAY,gBAAgB,CAAC,aAAa;AACxC,YAAM,eAAe,MAAM,UAAU;AAAA,QACnC,YAAY,iBAAiB;AA5BrC;AA6BU,gBAAM,oBAAmB,qBAAgB,YAAhB,mBAAyB;AAAA,YAChD,CAAC,WAAW,OAAO,SAAS;AAAA;AAE9B,cAAI,kBAAkB;AACpB,kBAAM,OAAmB;AAAA,cACvB;AAAA,gBACE,MAAM;AAAA,gBACN,MAAM;AAAA,gBACN,MAAM,YAAY,sBAAsB,MAAM;AAAA,gBAC9C,OAAO;AAAA,kBACL,MAAM;AAAA,kBACN,OAAO,iBAAiB;AAAA,kBACxB,KAAK,EAAE,MAAM,YAAY;AAAA,gBAC3B;AAAA,gBACA,KAAK,EAAE,MAAM,YAAY;AAAA,gBACzB,UAAU;AAAA,cACZ;AAAA,YACF;AACA,gBAAI,iBAAiB,SAAS;AAC5B,mBAAK,KAAK;AAAA,gBACR,MAAM;AAAA,gBACN,MAAM;AAAA,gBACN,MAAM,OAAO;AAAA,kBACX,OAAO,qBAAqB,WAAW;AAAA,gBACzC;AAAA,gBACA,OAAO;AAAA,kBACL,MAAM;AAAA,kBACN,OAAO,iBAAiB,QAAQ;AAAA,oBAC9B,CAAC,YAAY;AAAA,sBACX,MAAM;AAAA,sBACN,OAAO;AAAA,sBACP,KAAK,EAAE,MAAM,YAAY;AAAA,oBAC3B;AAAA,kBACF;AAAA,kBACA,KAAK,EAAE,MAAM,YAAY;AAAA,kBACzB,UAAU;AAAA,gBACZ;AAAA,gBACA,KAAK,EAAE,MAAM,YAAY;AAAA,gBACzB,UAAU;AAAA,cACZ,CAAC;AAAA,YACH;AACA,kBAAM,sBAAmC,iCACpC,kBADoC;AAAA,cAEvC,UAAS,qBAAgB,YAAhB,mBAAyB;AAAA,gBAChC,CAAC,WAAW,OAAO,SAAS;AAAA;AAAA,cAE9B,YAAY;AAAA,gBACV,GAAG,gBAAgB;AAAA,gBACnB;AAAA,kBACE,MAAM;AAAA,kBACN,MAAM;AAAA,kBACN;AAAA,kBACA,KAAK,EAAE,MAAM,YAAY;AAAA,kBACzB,UAAU;AAAA,gBACZ;AAAA,cACF;AAAA,YACF;AACA,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF,CAAC;AACD,oBAAc,YAAY,QAAQ,YAAY;AAAA,IAChD,CAAC;AAED,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/compilerTransforms/enableNodeWatchQueryTransform.d.ts

@@ -0,0 +1,9 @@
+import { IRTransform } from "relay-compiler/lib/core/CompilerContext";
+/**
+ * Uses relay-compiler's `@refetchable` directive to emit a query operation for
+ * a single fragment (on the `Node` interface or `Query` type). This operation
+ * is used by the `use*Fragment` hooks to observe the Apollo Client store for
+ * changes to _just_ that data selected in the fragment.
+ */
+export declare const enableNodeWatchQueryTransform: IRTransform;
+//# sourceMappingURL=enableNodeWatchQueryTransform.d.ts.map

package/lib/compilerTransforms/enableNodeWatchQueryTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableNodeWatchQueryTransform.d.ts","sourceRoot":"","sources":["../../src/compilerTransforms/enableNodeWatchQueryTransform.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAGtE;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,WAoB3C,CAAC"}

package/lib/compilerTransforms/enableNodeWatchQueryTransform.js

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var enableNodeWatchQueryTransform_exports = {};
+__export(enableNodeWatchQueryTransform_exports, {
+  enableNodeWatchQueryTransform: () => enableNodeWatchQueryTransform
+});
+module.exports = __toCommonJS(enableNodeWatchQueryTransform_exports);
+var import_utils = require("./utils");
+const enableNodeWatchQueryTransform = (context) => {
+  let nextContext = context;
+  context.forEachDocument((document) => {
+    if (document.kind === "Fragment" && (document.type === context.getSchema().getQueryType() || (0, import_utils.implementsNodeInterface)(context, document))) {
+      nextContext = nextContext.replace(__spreadProps(__spreadValues({}, document), {
+        directives: [
+          ...document.directives,
+          emitRefetchableDirective(document)
+        ]
+      }));
+    }
+  });
+  return nextContext;
+};
+function emitRefetchableDirective(fragmentDefinition) {
+  const fragmentName = fragmentDefinition.name;
+  const fragmentBaseName = fragmentName.replace(/Fragment$/, "");
+  return {
+    kind: "Directive",
+    name: "refetchable",
+    args: [
+      {
+        kind: "Argument",
+        name: "queryName",
+        value: {
+          kind: "Literal",
+          value: `${fragmentBaseName}WatchNodeQuery`,
+          loc: { kind: "Generated" }
+        },
+        loc: { kind: "Generated" },
+        metadata: void 0
+      }
+    ],
+    loc: { kind: "Generated" },
+    metadata: void 0
+  };
+}

package/lib/compilerTransforms/enableNodeWatchQueryTransform.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/compilerTransforms/enableNodeWatchQueryTransform.ts"],
+  "sourcesContent": ["import { Directive, Fragment } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { implementsNodeInterface } from \"./utils\";\n\n/**\n * Uses relay-compiler's `@refetchable` directive to emit a query operation for\n * a single fragment (on the `Node` interface or `Query` type). This operation\n * is used by the `use*Fragment` hooks to observe the Apollo Client store for\n * changes to _just_ that data selected in the fragment.\n */\nexport const enableNodeWatchQueryTransform: IRTransform = (context) => {\n  let nextContext = context;\n\n  context.forEachDocument((document) => {\n    if (\n      document.kind === \"Fragment\" &&\n      (document.type === context.getSchema().getQueryType() ||\n        implementsNodeInterface(context, document))\n    ) {\n      nextContext = nextContext.replace({\n        ...document,\n        directives: [\n          ...document.directives,\n          emitRefetchableDirective(document),\n        ],\n      });\n    }\n  });\n\n  return nextContext;\n};\n\nfunction emitRefetchableDirective(fragmentDefinition: Fragment): Directive {\n  const fragmentName = fragmentDefinition.name;\n  const fragmentBaseName = fragmentName.replace(/Fragment$/, \"\");\n  return {\n    kind: \"Directive\",\n    name: \"refetchable\",\n    args: [\n      {\n        kind: \"Argument\",\n        name: \"queryName\",\n        value: {\n          kind: \"Literal\",\n          value: `${fragmentBaseName}WatchNodeQuery`,\n          loc: { kind: \"Generated\" },\n        },\n        loc: { kind: \"Generated\" },\n        metadata: undefined,\n      },\n    ],\n    loc: { kind: \"Generated\" },\n    metadata: undefined,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAAwC;AAQjC,MAAM,gCAA6C,CAAC,YAAY;AACrE,MAAI,cAAc;AAElB,UAAQ,gBAAgB,CAAC,aAAa;AACpC,QACE,SAAS,SAAS,eACjB,SAAS,SAAS,QAAQ,UAAU,EAAE,aAAa,SAClD,sCAAwB,SAAS,QAAQ,IAC3C;AACA,oBAAc,YAAY,QAAQ,iCAC7B,WAD6B;AAAA,QAEhC,YAAY;AAAA,UACV,GAAG,SAAS;AAAA,UACZ,yBAAyB,QAAQ;AAAA,QACnC;AAAA,MACF,EAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEA,SAAS,yBAAyB,oBAAyC;AACzE,QAAM,eAAe,mBAAmB;AACxC,QAAM,mBAAmB,aAAa,QAAQ,aAAa,EAAE;AAC7D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,MACJ;AAAA,QACE,MAAM;AAAA,QACN,MAAM;AAAA,QACN,OAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,GAAG;AAAA,UACV,KAAK,EAAE,MAAM,YAAY;AAAA,QAC3B;AAAA,QACA,KAAK,EAAE,MAAM,YAAY;AAAA,QACzB,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,IACA,KAAK,EAAE,MAAM,YAAY;AAAA,IACzB,UAAU;AAAA,EACZ;AACF;",
+  "names": []
+}

package/lib/compilerTransforms/enableNodeWatchQueryTransform.mjs

@@ -0,0 +1,62 @@
+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/compilerTransforms/enableNodeWatchQueryTransform.ts
+import { implementsNodeInterface } from "./utils.mjs";
+var enableNodeWatchQueryTransform = (context) => {
+  let nextContext = context;
+  context.forEachDocument((document) => {
+    if (document.kind === "Fragment" && (document.type === context.getSchema().getQueryType() || implementsNodeInterface(context, document))) {
+      nextContext = nextContext.replace(__spreadProps(__spreadValues({}, document), {
+        directives: [
+          ...document.directives,
+          emitRefetchableDirective(document)
+        ]
+      }));
+    }
+  });
+  return nextContext;
+};
+function emitRefetchableDirective(fragmentDefinition) {
+  const fragmentName = fragmentDefinition.name;
+  const fragmentBaseName = fragmentName.replace(/Fragment$/, "");
+  return {
+    kind: "Directive",
+    name: "refetchable",
+    args: [
+      {
+        kind: "Argument",
+        name: "queryName",
+        value: {
+          kind: "Literal",
+          value: `${fragmentBaseName}WatchNodeQuery`,
+          loc: { kind: "Generated" }
+        },
+        loc: { kind: "Generated" },
+        metadata: void 0
+      }
+    ],
+    loc: { kind: "Generated" },
+    metadata: void 0
+  };
+}
+export {
+  enableNodeWatchQueryTransform
+};

package/lib/compilerTransforms/enableNodeWatchQueryTransform.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/compilerTransforms/enableNodeWatchQueryTransform.ts"],
+  "sourcesContent": ["import { Directive, Fragment } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { implementsNodeInterface } from \"./utils\";\n\n/**\n * Uses relay-compiler's `@refetchable` directive to emit a query operation for\n * a single fragment (on the `Node` interface or `Query` type). This operation\n * is used by the `use*Fragment` hooks to observe the Apollo Client store for\n * changes to _just_ that data selected in the fragment.\n */\nexport const enableNodeWatchQueryTransform: IRTransform = (context) => {\n  let nextContext = context;\n\n  context.forEachDocument((document) => {\n    if (\n      document.kind === \"Fragment\" &&\n      (document.type === context.getSchema().getQueryType() ||\n        implementsNodeInterface(context, document))\n    ) {\n      nextContext = nextContext.replace({\n        ...document,\n        directives: [\n          ...document.directives,\n          emitRefetchableDirective(document),\n        ],\n      });\n    }\n  });\n\n  return nextContext;\n};\n\nfunction emitRefetchableDirective(fragmentDefinition: Fragment): Directive {\n  const fragmentName = fragmentDefinition.name;\n  const fragmentBaseName = fragmentName.replace(/Fragment$/, \"\");\n  return {\n    kind: \"Directive\",\n    name: \"refetchable\",\n    args: [\n      {\n        kind: \"Argument\",\n        name: \"queryName\",\n        value: {\n          kind: \"Literal\",\n          value: `${fragmentBaseName}WatchNodeQuery`,\n          loc: { kind: \"Generated\" },\n        },\n        loc: { kind: \"Generated\" },\n        metadata: undefined,\n      },\n    ],\n    loc: { kind: \"Generated\" },\n    metadata: undefined,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAEA,SAAS,+BAA+B;AAQjC,IAAM,gCAA6C,CAAC,YAAY;AACrE,MAAI,cAAc;AAElB,UAAQ,gBAAgB,CAAC,aAAa;AACpC,QACE,SAAS,SAAS,eACjB,SAAS,SAAS,QAAQ,UAAU,EAAE,aAAa,KAClD,wBAAwB,SAAS,QAAQ,IAC3C;AACA,oBAAc,YAAY,QAAQ,iCAC7B,WAD6B;AAAA,QAEhC,YAAY;AAAA,UACV,GAAG,SAAS;AAAA,UACZ,yBAAyB,QAAQ;AAAA,QACnC;AAAA,MACF,EAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEA,SAAS,yBAAyB,oBAAyC;AACzE,QAAM,eAAe,mBAAmB;AACxC,QAAM,mBAAmB,aAAa,QAAQ,aAAa,EAAE;AAC7D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,MACJ;AAAA,QACE,MAAM;AAAA,QACN,MAAM;AAAA,QACN,OAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,GAAG;AAAA,UACV,KAAK,EAAE,MAAM,YAAY;AAAA,QAC3B;AAAA,QACA,KAAK,EAAE,MAAM,YAAY;AAAA,QACzB,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,IACA,KAAK,EAAE,MAAM,YAAY;AAAA,IACzB,UAAU;AAAA,EACZ;AACF;",
+  "names": []
+}

package/lib/compilerTransforms/retainConnectionDirectiveTransform.d.ts

@@ -0,0 +1,13 @@
+import { IRTransform } from "relay-compiler/lib/core/CompilerContext";
+/**
+ * relay-compiler will strip out all of its client-specific directives, which
+ * makes sense as these should normally not be sent to the schema, but in our
+ * case we want to keep this directive as we will need to send it to Apollo
+ * Client. So we collect all the directives, let the relay-compiler filter
+ * transform do its work, and then re-instate the connection directives.
+ *
+ * @param wrappedFilterDirectivesTransform
+ *   relay-compiler's filter directives transform
+ */
+export declare function retainConnectionDirectiveTransform(wrappedFilterDirectivesTransform: IRTransform): IRTransform;
+//# sourceMappingURL=retainConnectionDirectiveTransform.d.ts.map

package/lib/compilerTransforms/retainConnectionDirectiveTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainConnectionDirectiveTransform.d.ts","sourceRoot":"","sources":["../../src/compilerTransforms/retainConnectionDirectiveTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAMtE;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAChD,gCAAgC,EAAE,WAAW,GAC5C,WAAW,CAwDb"}

package/lib/compilerTransforms/retainConnectionDirectiveTransform.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retainConnectionDirectiveTransform_exports = {};
+__export(retainConnectionDirectiveTransform_exports, {
+  retainConnectionDirectiveTransform: () => retainConnectionDirectiveTransform
+});
+module.exports = __toCommonJS(retainConnectionDirectiveTransform_exports);
+var import_IRVisitor = require("relay-compiler/lib/core/IRVisitor");
+function retainConnectionDirectiveTransform(wrappedFilterDirectivesTransform) {
+  const filterDirectivesTransformWrapper = (context) => {
+    let nextContext = context;
+    const documentsWithConnectionDirectives = {};
+    nextContext.forEachDocument((document) => {
+      const fieldPathsWithConnectionDirectives = [];
+      (0, import_IRVisitor.visit)(document, {
+        Directive(directiveNode, _key, _parent, path) {
+          if (directiveNode.name === "connection") {
+            fieldPathsWithConnectionDirectives.push([
+              path.slice(0, -2),
+              directiveNode
+            ]);
+          }
+        }
+      });
+      documentsWithConnectionDirectives[document.name] = fieldPathsWithConnectionDirectives;
+    });
+    nextContext = wrappedFilterDirectivesTransform(context);
+    nextContext.forEachDocument((document) => {
+      const fieldPathsWithConnectionDirectives = documentsWithConnectionDirectives[document.name];
+      if (fieldPathsWithConnectionDirectives.length > 0) {
+        const nextDocument = (0, import_IRVisitor.visit)(document, {
+          LinkedField(linkedFieldNode, _key, _parent, path) {
+            const match = fieldPathsWithConnectionDirectives.find(
+              ([p, _]) => path.length === p.length && path.every((x, i) => p[i] === x)
+            );
+            if (match) {
+              const nextLinkedFieldNode = __spreadProps(__spreadValues({}, linkedFieldNode), {
+                directives: [...linkedFieldNode.directives, match[1]]
+              });
+              return nextLinkedFieldNode;
+            }
+          }
+        });
+        nextContext = nextContext.replace(nextDocument);
+      }
+    });
+    return nextContext;
+  };
+  return filterDirectivesTransformWrapper;
+}