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

package/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Change Log - relay-compiler-language-graphitation
+
+This log was last generated on Mon, 24 Jan 2022 13:40:52 GMT and should not be manually modified.
+
+<!-- Start content -->
+
+## 0.8.2
+
+Mon, 24 Jan 2022 13:40:52 GMT
+
+### Patches
+
+- Fix Webpack 4 compat (mnovikov@microsoft.com)
+
+## 0.8.1
+
+Thu, 06 Jan 2022 09:53:33 GMT
+
+### Patches
+
+- typecript version changed from ^4.2.3 to >=4.2.3 based on https://github.com/microsoft/graphitation/pull/78 (jakubvejr@microsoft.com)
+
+## 0.8.0
+
+Wed, 05 Jan 2022 15:09:43 GMT
+
+### Minor changes
+
+- We were facing an error in relay-compiler-language-typescript: 14.0.0. issue described here, which caused a syntax error in generated files. With >=14.0.0 in this update we wanted to not force apps which use the graphitation plugin to have TS version 4.5 or greater. (jakubvejr@microsoft.com)
+
+## 0.7.0
+
+Thu, 23 Dec 2021 11:31:14 GMT
+
+### Minor changes
+
+- Added proper mjs builds (bump for main release) (mnovikov@microsoft.com)
+
+## 0.6.0
+
+Tue, 14 Dec 2021 10:13:54 GMT
+
+### Minor changes
+
+- Support ESM in distro packages (mnovikov@microsoft.com)
+
+## 0.5.3
+
+Tue, 26 Oct 2021 21:09:29 GMT
+
+### Patches
+
+- Ensure that all packages listing graphql as a peerDependency also has it as a devDependency (modevold@microsoft.com)
+
+## 0.5.2
+
+Tue, 26 Oct 2021 12:46:12 GMT
+
+### Patches
+
+- Align graphql dependency to version ^15.0.0 across packages (modevold@microsoft.com)
+
+## 0.5.1
+
+Sat, 24 Apr 2021 23:10:54 GMT
+
+### Patches
+
+- Include commonjs modules (eloy.de.enige@gmail.com)
+
+## 0.5.0
+
+Fri, 23 Apr 2021 21:44:28 GMT
+
+### Minor changes
+
+- First proper release (eloy.de.enige@gmail.com)
+
+### Patches
+
+- fixing the publish process, publishing a new patch level (kchau@microsoft.com)
+- fixing the publish process, publishing a new patch level (again) (kchau@microsoft.com)
+- Include correct files (eloy.de.enige@gmail.com)

package/README.md

@@ -0,0 +1,3 @@
+# @graphitation/apollo-react-relay-duct-tape-compiler
+
+This package contains all the build tooling needed to support the `@graphitation/apollo-react-relay-duct-tape` package.

package/lib/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/lib/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/lib/cli.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+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 __getProtoOf = Object.getPrototypeOf;
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var yargs = __toESM(require("yargs"));
+var import_relay_compiler = require("relay-compiler");
+var import_relayCompilerLanguagePlugin = require("./relayCompilerLanguagePlugin");
+var import_relay_compiler2 = require("relay-compiler");
+var import_enableNodeWatchQueryTransform = require("./compilerTransforms/enableNodeWatchQueryTransform");
+var import_annotateFragmentReferenceTransform = require("./compilerTransforms/annotateFragmentReferenceTransform");
+var import_emitApolloClientConnectionTransform = require("./compilerTransforms/emitApolloClientConnectionTransform");
+var import_retainConnectionDirectiveTransform = require("./compilerTransforms/retainConnectionDirectiveTransform");
+function wrapTransform(transformName, transforms, wrapperTransform) {
+  const transformIndex = transforms.findIndex(
+    (transform) => transform.name === transformName
+  );
+  const wrappedTransform = transforms[transformIndex];
+  transforms[transformIndex] = wrapperTransform(wrappedTransform);
+}
+wrapTransform(
+  "filterDirectivesTransform",
+  import_relay_compiler2.IRTransforms.printTransforms,
+  import_retainConnectionDirectiveTransform.retainConnectionDirectiveTransform
+);
+wrapTransform(
+  "connectionTransform",
+  import_relay_compiler2.IRTransforms.commonTransforms,
+  import_emitApolloClientConnectionTransform.emitApolloClientConnectionTransform
+);
+function main() {
+  return __async(this, null, function* () {
+    const argv = yield yargs.scriptName("duct-tape-compiler").options({
+      src: {
+        demandOption: false,
+        default: ".",
+        type: "string"
+      },
+      exclude: {
+        demandOption: false,
+        type: "string",
+        array: true
+      },
+      include: {
+        demandOption: false,
+        type: "string",
+        array: true
+      },
+      schema: {
+        demandOption: true,
+        type: "string"
+      },
+      validate: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      verbose: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      watch: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      watchman: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      quiet: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      emitDocuments: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      emitNarrowObservables: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      emitQueryDebugComments: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      emitSupermassiveDocuments: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      }
+    }).help().argv;
+    if (!argv.emitDocuments) {
+      argv.emitNarrowObservables = false;
+      argv.emitQueryDebugComments = false;
+    }
+    if (argv.emitNarrowObservables) {
+      import_relay_compiler2.IRTransforms.printTransforms.push(import_annotateFragmentReferenceTransform.annotateFragmentReferenceTransform);
+      import_relay_compiler2.IRTransforms.commonTransforms.unshift(import_enableNodeWatchQueryTransform.enableNodeWatchQueryTransform);
+    }
+    const ductTapeCompilerLanguagePlugin = yield (0, import_relayCompilerLanguagePlugin.pluginFactory)(argv);
+    return (0, import_relay_compiler.relayCompiler)(__spreadProps(__spreadValues({}, argv), {
+      language: ductTapeCompilerLanguagePlugin,
+      extensions: ["ts", "tsx"],
+      // FIXME: Why is this not taken from the language plugin?
+      include: argv.include || ["**"],
+      exclude: [
+        "**/node_modules/**",
+        "**/__mocks__/**",
+        "**/__generated__/**",
+        // relay-compiler will treat these as client-side schema extensions
+        "**/*.graphql",
+        ...argv.exclude || []
+      ],
+      noFutureProofEnums: true,
+      customScalars: {}
+    }));
+  });
+}
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/lib/cli.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cli.ts"],
+  "sourcesContent": ["#!/usr/bin/env node\n\n/* istanbul ignore file */\n\nimport * as yargs from \"yargs\";\nimport { relayCompiler } from \"relay-compiler\";\nimport { pluginFactory } from \"./relayCompilerLanguagePlugin\";\n\n// TODO: This needs to be done here to ensure we get to mutate the transforms lists that get used.\nimport { IRTransforms } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { enableNodeWatchQueryTransform } from \"./compilerTransforms/enableNodeWatchQueryTransform\";\nimport { annotateFragmentReferenceTransform } from \"./compilerTransforms/annotateFragmentReferenceTransform\";\nimport { emitApolloClientConnectionTransform } from \"./compilerTransforms/emitApolloClientConnectionTransform\";\nimport { retainConnectionDirectiveTransform } from \"./compilerTransforms/retainConnectionDirectiveTransform\";\n\nfunction wrapTransform(\n  transformName: string,\n  transforms: IRTransform[],\n  wrapperTransform: (wrappedTransform: IRTransform) => IRTransform,\n) {\n  const transformIndex = transforms.findIndex(\n    (transform) => transform.name === transformName,\n  );\n  const wrappedTransform = transforms[transformIndex];\n  transforms[transformIndex] = wrapperTransform(wrappedTransform);\n}\n\nwrapTransform(\n  \"filterDirectivesTransform\",\n  IRTransforms.printTransforms,\n  retainConnectionDirectiveTransform,\n);\nwrapTransform(\n  \"connectionTransform\",\n  IRTransforms.commonTransforms,\n  emitApolloClientConnectionTransform,\n);\n\nasync function main() {\n  const argv = await yargs\n    .scriptName(\"duct-tape-compiler\")\n    .options({\n      src: {\n        demandOption: false,\n        default: \".\",\n        type: \"string\",\n      },\n      exclude: {\n        demandOption: false,\n        type: \"string\",\n        array: true,\n      },\n      include: {\n        demandOption: false,\n        type: \"string\",\n        array: true,\n      },\n      schema: {\n        demandOption: true,\n        type: \"string\",\n      },\n      validate: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      verbose: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      watch: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      watchman: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      quiet: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      emitDocuments: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      emitNarrowObservables: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      emitQueryDebugComments: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      emitSupermassiveDocuments: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n    })\n    .help().argv;\n\n  if (!argv.emitDocuments) {\n    argv.emitNarrowObservables = false;\n    argv.emitQueryDebugComments = false;\n  }\n\n  if (argv.emitNarrowObservables) {\n    // TODO: Moving this up in the list might potentially optimize the query further\n    IRTransforms.printTransforms.push(annotateFragmentReferenceTransform);\n    IRTransforms.commonTransforms.unshift(enableNodeWatchQueryTransform);\n  }\n\n  const ductTapeCompilerLanguagePlugin = await pluginFactory(argv);\n\n  return relayCompiler({\n    ...argv,\n    language: ductTapeCompilerLanguagePlugin,\n    extensions: [\"ts\", \"tsx\"], // FIXME: Why is this not taken from the language plugin?\n    include: argv.include || [\"**\"],\n    exclude: [\n      \"**/node_modules/**\",\n      \"**/__mocks__/**\",\n      \"**/__generated__/**\",\n      // relay-compiler will treat these as client-side schema extensions\n      \"**/*.graphql\",\n      ...(argv.exclude || []),\n    ],\n    noFutureProofEnums: true,\n    customScalars: {},\n  });\n}\n\nmain().catch((error) => {\n  console.error(error);\n  process.exit(1);\n});\n"],
+  "mappings": "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",
+  "names": ["import_relay_compiler"]
+}

package/lib/cli.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/cli.ts
+import * as yargs from "yargs";
+import { relayCompiler } from "relay-compiler";
+import { pluginFactory } from "./relayCompilerLanguagePlugin.mjs";
+import { IRTransforms } from "relay-compiler";
+import { enableNodeWatchQueryTransform } from "./compilerTransforms/enableNodeWatchQueryTransform.mjs";
+import { annotateFragmentReferenceTransform } from "./compilerTransforms/annotateFragmentReferenceTransform.mjs";
+import { emitApolloClientConnectionTransform } from "./compilerTransforms/emitApolloClientConnectionTransform.mjs";
+import { retainConnectionDirectiveTransform } from "./compilerTransforms/retainConnectionDirectiveTransform.mjs";
+function wrapTransform(transformName, transforms, wrapperTransform) {
+  const transformIndex = transforms.findIndex(
+    (transform) => transform.name === transformName
+  );
+  const wrappedTransform = transforms[transformIndex];
+  transforms[transformIndex] = wrapperTransform(wrappedTransform);
+}
+wrapTransform(
+  "filterDirectivesTransform",
+  IRTransforms.printTransforms,
+  retainConnectionDirectiveTransform
+);
+wrapTransform(
+  "connectionTransform",
+  IRTransforms.commonTransforms,
+  emitApolloClientConnectionTransform
+);
+function main() {
+  return __async(this, null, function* () {
+    const argv = yield yargs.scriptName("duct-tape-compiler").options({
+      src: {
+        demandOption: false,
+        default: ".",
+        type: "string"
+      },
+      exclude: {
+        demandOption: false,
+        type: "string",
+        array: true
+      },
+      include: {
+        demandOption: false,
+        type: "string",
+        array: true
+      },
+      schema: {
+        demandOption: true,
+        type: "string"
+      },
+      validate: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      verbose: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      watch: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      watchman: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      quiet: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      emitDocuments: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      emitNarrowObservables: {
+        demandOption: false,
+        default: true,
+        type: "boolean"
+      },
+      emitQueryDebugComments: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      },
+      emitSupermassiveDocuments: {
+        demandOption: false,
+        default: false,
+        type: "boolean"
+      }
+    }).help().argv;
+    if (!argv.emitDocuments) {
+      argv.emitNarrowObservables = false;
+      argv.emitQueryDebugComments = false;
+    }
+    if (argv.emitNarrowObservables) {
+      IRTransforms.printTransforms.push(annotateFragmentReferenceTransform);
+      IRTransforms.commonTransforms.unshift(enableNodeWatchQueryTransform);
+    }
+    const ductTapeCompilerLanguagePlugin = yield pluginFactory(argv);
+    return relayCompiler(__spreadProps(__spreadValues({}, argv), {
+      language: ductTapeCompilerLanguagePlugin,
+      extensions: ["ts", "tsx"],
+      // FIXME: Why is this not taken from the language plugin?
+      include: argv.include || ["**"],
+      exclude: [
+        "**/node_modules/**",
+        "**/__mocks__/**",
+        "**/__generated__/**",
+        // relay-compiler will treat these as client-side schema extensions
+        "**/*.graphql",
+        ...argv.exclude || []
+      ],
+      noFutureProofEnums: true,
+      customScalars: {}
+    }));
+  });
+}
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/lib/cli.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cli.ts"],
+  "sourcesContent": ["#!/usr/bin/env node\n\n/* istanbul ignore file */\n\nimport * as yargs from \"yargs\";\nimport { relayCompiler } from \"relay-compiler\";\nimport { pluginFactory } from \"./relayCompilerLanguagePlugin\";\n\n// TODO: This needs to be done here to ensure we get to mutate the transforms lists that get used.\nimport { IRTransforms } from \"relay-compiler\";\nimport { IRTransform } from \"relay-compiler/lib/core/CompilerContext\";\nimport { enableNodeWatchQueryTransform } from \"./compilerTransforms/enableNodeWatchQueryTransform\";\nimport { annotateFragmentReferenceTransform } from \"./compilerTransforms/annotateFragmentReferenceTransform\";\nimport { emitApolloClientConnectionTransform } from \"./compilerTransforms/emitApolloClientConnectionTransform\";\nimport { retainConnectionDirectiveTransform } from \"./compilerTransforms/retainConnectionDirectiveTransform\";\n\nfunction wrapTransform(\n  transformName: string,\n  transforms: IRTransform[],\n  wrapperTransform: (wrappedTransform: IRTransform) => IRTransform,\n) {\n  const transformIndex = transforms.findIndex(\n    (transform) => transform.name === transformName,\n  );\n  const wrappedTransform = transforms[transformIndex];\n  transforms[transformIndex] = wrapperTransform(wrappedTransform);\n}\n\nwrapTransform(\n  \"filterDirectivesTransform\",\n  IRTransforms.printTransforms,\n  retainConnectionDirectiveTransform,\n);\nwrapTransform(\n  \"connectionTransform\",\n  IRTransforms.commonTransforms,\n  emitApolloClientConnectionTransform,\n);\n\nasync function main() {\n  const argv = await yargs\n    .scriptName(\"duct-tape-compiler\")\n    .options({\n      src: {\n        demandOption: false,\n        default: \".\",\n        type: \"string\",\n      },\n      exclude: {\n        demandOption: false,\n        type: \"string\",\n        array: true,\n      },\n      include: {\n        demandOption: false,\n        type: \"string\",\n        array: true,\n      },\n      schema: {\n        demandOption: true,\n        type: \"string\",\n      },\n      validate: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      verbose: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      watch: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      watchman: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      quiet: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      emitDocuments: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      emitNarrowObservables: {\n        demandOption: false,\n        default: true,\n        type: \"boolean\",\n      },\n      emitQueryDebugComments: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n      emitSupermassiveDocuments: {\n        demandOption: false,\n        default: false,\n        type: \"boolean\",\n      },\n    })\n    .help().argv;\n\n  if (!argv.emitDocuments) {\n    argv.emitNarrowObservables = false;\n    argv.emitQueryDebugComments = false;\n  }\n\n  if (argv.emitNarrowObservables) {\n    // TODO: Moving this up in the list might potentially optimize the query further\n    IRTransforms.printTransforms.push(annotateFragmentReferenceTransform);\n    IRTransforms.commonTransforms.unshift(enableNodeWatchQueryTransform);\n  }\n\n  const ductTapeCompilerLanguagePlugin = await pluginFactory(argv);\n\n  return relayCompiler({\n    ...argv,\n    language: ductTapeCompilerLanguagePlugin,\n    extensions: [\"ts\", \"tsx\"], // FIXME: Why is this not taken from the language plugin?\n    include: argv.include || [\"**\"],\n    exclude: [\n      \"**/node_modules/**\",\n      \"**/__mocks__/**\",\n      \"**/__generated__/**\",\n      // relay-compiler will treat these as client-side schema extensions\n      \"**/*.graphql\",\n      ...(argv.exclude || []),\n    ],\n    noFutureProofEnums: true,\n    customScalars: {},\n  });\n}\n\nmain().catch((error) => {\n  console.error(error);\n  process.exit(1);\n});\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/compilerTransforms/annotateFragmentReferenceTransform.d.ts

@@ -0,0 +1,13 @@
+import { IRTransform } from "relay-compiler/lib/core/CompilerContext";
+/**
+ * Inserts a `__fragments` selection at the place where a fragment reference
+ * boundary exists. This is either done in a `Node` inline fragment or directly
+ * on the `Query` type.
+ *
+ * This field, which is an Apollo Client client-side field as declared with the
+ * `@client` directive, will be used to pass context between the `use*Fragment`
+ * hooks. (Currently this is limited to request variables.) The data for this
+ * field is resolved by the `fragmentReferencesFieldPolicy` function.
+ */
+export declare const annotateFragmentReferenceTransform: IRTransform;
+//# sourceMappingURL=annotateFragmentReferenceTransform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"annotateFragmentReferenceTransform.d.ts","sourceRoot":"","sources":["../../src/compilerTransforms/annotateFragmentReferenceTransform.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAgCtE;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC,EAAE,WAehD,CAAC"}

package/lib/compilerTransforms/annotateFragmentReferenceTransform.js

@@ -0,0 +1,98 @@
+"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 annotateFragmentReferenceTransform_exports = {};
+__export(annotateFragmentReferenceTransform_exports, {
+  annotateFragmentReferenceTransform: () => annotateFragmentReferenceTransform
+});
+module.exports = __toCommonJS(annotateFragmentReferenceTransform_exports);
+var import_IRVisitor = require("relay-compiler/lib/core/IRVisitor");
+var import_utils = require("./utils");
+const 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
+};
+const FRAGMENTS_ON_NODE_SELECTION = {
+  kind: "InlineFragment",
+  typeCondition: "Node",
+  selections: [FRAGMENTS_SELECTION],
+  directives: [],
+  loc: { kind: "Generated" },
+  metadata: void 0
+};
+const annotateFragmentReferenceTransform = (context) => {
+  const visitor = visitNodeWithSelections.bind(null, context);
+  let nextContext = context;
+  context.forEachDocument((document) => {
+    const nextDocument = (0, import_IRVisitor.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 ((0, import_utils.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]
+        });
+      }
+    }
+  }
+}

package/lib/compilerTransforms/annotateFragmentReferenceTransform.js.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,uBAAsB;AACtB,mBAAwC;AAExC,MAAM,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,MAAM,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,MAAM,qCAAkD,CAAC,YAAY;AAC1E,QAAM,UAAU,wBAAwB,KAAK,MAAM,OAAO;AAC1D,MAAI,cAAc;AAElB,UAAQ,gBAAgB,CAAC,aAAa;AACpC,UAAM,mBAAe,wBAAM,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,cAAI,sCAAwB,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": []
+}