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

package/lib/rewriteGraphitationDirectives.mjs

@@ -0,0 +1,83 @@
+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/rewriteGraphitationDirectives.ts
+import {
+  parse,
+  print,
+  visit
+} from "graphql";
+import invariant from "invariant";
+function rewriteGraphitationDirectives(document) {
+  const documentNode = parse(document);
+  const rewrittenDocumentNode = visit(documentNode, {
+    Directive(directiveNode, _key, _parent, _path, ancestors) {
+      switch (directiveNode.name.value) {
+        case "watchNode": {
+          const fragmentDefinitionNode = ancestors[ancestors.length - 1];
+          invariant(
+            !Array.isArray(fragmentDefinitionNode) && fragmentDefinitionNode.kind === "FragmentDefinition",
+            "Expected @watchNode to be used on a fragment"
+          );
+          return emitRefetchableDirective(fragmentDefinitionNode);
+        }
+        case "graphitation_test_operation": {
+          return __spreadProps(__spreadValues({}, directiveNode), {
+            name: {
+              kind: "Name",
+              value: "raw_response_type"
+            }
+          });
+        }
+        default: {
+          return void 0;
+        }
+      }
+    }
+  });
+  return print(rewrittenDocumentNode);
+}
+function emitRefetchableDirective(fragmentDefinitionNode) {
+  const fragmentName = fragmentDefinitionNode.name.value;
+  const fragmentBaseName = fragmentName.replace(/Fragment$/, "");
+  return {
+    kind: "Directive",
+    name: {
+      kind: "Name",
+      value: "refetchable"
+    },
+    arguments: [
+      {
+        kind: "Argument",
+        name: {
+          kind: "Name",
+          value: "queryName"
+        },
+        value: {
+          kind: "StringValue",
+          value: `${fragmentBaseName}WatchNodeQuery`
+        }
+      }
+    ]
+  };
+}
+export {
+  rewriteGraphitationDirectives
+};

package/lib/rewriteGraphitationDirectives.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/rewriteGraphitationDirectives.ts"],
+  "sourcesContent": ["import {\n  DirectiveNode,\n  parse,\n  print,\n  visit,\n  ASTNode,\n  FragmentDefinitionNode,\n} from \"graphql\";\nimport invariant from \"invariant\";\n\ndeclare global {\n  interface ArrayConstructor {\n    isArray(arg: ReadonlyArray<any> | any): arg is ReadonlyArray<any>;\n  }\n}\n\n/**\n * This rewrites graphitation specific directives to relay ones. Currently it does the following:\n *\n * - `@graphitation_test_operation` is rewritten to `@raw_response_type`.\n *   In the future this should probably also add `@relay_test_operation`.\n *\n * @param document A single GraphQL document\n */\nexport function rewriteGraphitationDirectives(document: string) {\n  const documentNode = parse(document);\n  const rewrittenDocumentNode = visit(documentNode, {\n    Directive(\n      directiveNode,\n      _key,\n      _parent,\n      _path,\n      ancestors,\n    ): DirectiveNode | undefined {\n      switch (directiveNode.name.value) {\n        case \"watchNode\": {\n          const fragmentDefinitionNode = ancestors[ancestors.length - 1];\n          invariant(\n            !Array.isArray(fragmentDefinitionNode) &&\n              fragmentDefinitionNode.kind === \"FragmentDefinition\",\n            \"Expected @watchNode to be used on a fragment\",\n          );\n          return emitRefetchableDirective(fragmentDefinitionNode);\n        }\n        case \"graphitation_test_operation\": {\n          return {\n            ...directiveNode,\n            name: {\n              kind: \"Name\",\n              value: \"raw_response_type\",\n            },\n          };\n        }\n        default: {\n          return undefined;\n        }\n      }\n    },\n  });\n  return print(rewrittenDocumentNode);\n}\n\nfunction emitRefetchableDirective(\n  fragmentDefinitionNode: FragmentDefinitionNode,\n): DirectiveNode {\n  const fragmentName = fragmentDefinitionNode.name.value;\n  const fragmentBaseName = fragmentName.replace(/Fragment$/, \"\");\n  return {\n    kind: \"Directive\",\n    name: {\n      kind: \"Name\",\n      value: \"refetchable\",\n    },\n    arguments: [\n      {\n        kind: \"Argument\",\n        name: {\n          kind: \"Name\",\n          value: \"queryName\",\n        },\n        value: {\n          kind: \"StringValue\",\n          value: `${fragmentBaseName}WatchNodeQuery`,\n        },\n      },\n    ],\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,OAAO,eAAe;AAgBf,SAAS,8BAA8B,UAAkB;AAC9D,QAAM,eAAe,MAAM,QAAQ;AACnC,QAAM,wBAAwB,MAAM,cAAc;AAAA,IAChD,UACE,eACA,MACA,SACA,OACA,WAC2B;AAC3B,cAAQ,cAAc,KAAK,OAAO;AAAA,QAChC,KAAK,aAAa;AAChB,gBAAM,yBAAyB,UAAU,UAAU,SAAS,CAAC;AAC7D;AAAA,YACE,CAAC,MAAM,QAAQ,sBAAsB,KACnC,uBAAuB,SAAS;AAAA,YAClC;AAAA,UACF;AACA,iBAAO,yBAAyB,sBAAsB;AAAA,QACxD;AAAA,QACA,KAAK,+BAA+B;AAClC,iBAAO,iCACF,gBADE;AAAA,YAEL,MAAM;AAAA,cACJ,MAAM;AAAA,cACN,OAAO;AAAA,YACT;AAAA,UACF;AAAA,QACF;AAAA,QACA,SAAS;AACP,iBAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACD,SAAO,MAAM,qBAAqB;AACpC;AAEA,SAAS,yBACP,wBACe;AACf,QAAM,eAAe,uBAAuB,KAAK;AACjD,QAAM,mBAAmB,aAAa,QAAQ,aAAa,EAAE;AAC7D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,MACJ,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,IACA,WAAW;AAAA,MACT;AAAA,QACE,MAAM;AAAA,QACN,MAAM;AAAA,UACJ,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,QACA,OAAO;AAAA,UACL,MAAM;AAAA,UACN,OAAO,GAAG;AAAA,QACZ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/lib/typeGenerator.d.ts

@@ -0,0 +1,3 @@
+import { TypeGenerator } from "relay-compiler/lib/language/RelayLanguagePluginInterface";
+export declare function generateFactory(wrappedGenerate: TypeGenerator["generate"]): (schema: import("relay-compiler").Schema, node: import("relay-compiler").Fragment | import("relay-compiler").Root, options: import("relay-compiler/lib/language/RelayLanguagePluginInterface").TypeGeneratorOptions) => string;
+//# sourceMappingURL=typeGenerator.d.ts.map

package/lib/typeGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGenerator.d.ts","sourceRoot":"","sources":["../src/typeGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0DAA0D,CAAC;AAEzF,wBAAgB,eAAe,CAAC,eAAe,EAAE,aAAa,CAAC,UAAU,CAAC,kOAYzE"}

package/lib/typeGenerator.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 typeGenerator_exports = {};
+__export(typeGenerator_exports, {
+  generateFactory: () => generateFactory
+});
+module.exports = __toCommonJS(typeGenerator_exports);
+function generateFactory(wrappedGenerate) {
+  const generate = (schema, node, options) => {
+    const generated = wrappedGenerate(schema, node, options);
+    return generated.replace("relay-runtime", "@graphitation/apollo-react-relay-duct-tape").replace(/^\s+readonly __is[A-Z].+;\n/gm, "");
+  };
+  return generate;
+}

package/lib/typeGenerator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/typeGenerator.ts"],
+  "sourcesContent": ["import { TypeGenerator } from \"relay-compiler/lib/language/RelayLanguagePluginInterface\";\n\nexport function generateFactory(wrappedGenerate: TypeGenerator[\"generate\"]) {\n  const generate: TypeGenerator[\"generate\"] = (schema, node, options) => {\n    const generated = wrappedGenerate(schema, node, options);\n    return (\n      generated\n        .replace(\"relay-runtime\", \"@graphitation/apollo-react-relay-duct-tape\")\n        // These fields in the `@raw_response_type` output are really just for relay-runtime, so for now we can just\n        // strip them out entirely.\n        .replace(/^\\s+readonly __is[A-Z].+;\\n/gm, \"\")\n    );\n  };\n  return generate;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEO,SAAS,gBAAgB,iBAA4C;AAC1E,QAAM,WAAsC,CAAC,QAAQ,MAAM,YAAY;AACrE,UAAM,YAAY,gBAAgB,QAAQ,MAAM,OAAO;AACvD,WACE,UACG,QAAQ,iBAAiB,4CAA4C,EAGrE,QAAQ,iCAAiC,EAAE;AAAA,EAElD;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/typeGenerator.mjs

@@ -0,0 +1,11 @@
+// src/typeGenerator.ts
+function generateFactory(wrappedGenerate) {
+  const generate = (schema, node, options) => {
+    const generated = wrappedGenerate(schema, node, options);
+    return generated.replace("relay-runtime", "@graphitation/apollo-react-relay-duct-tape").replace(/^\s+readonly __is[A-Z].+;\n/gm, "");
+  };
+  return generate;
+}
+export {
+  generateFactory
+};

package/lib/typeGenerator.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/typeGenerator.ts"],
+  "sourcesContent": ["import { TypeGenerator } from \"relay-compiler/lib/language/RelayLanguagePluginInterface\";\n\nexport function generateFactory(wrappedGenerate: TypeGenerator[\"generate\"]) {\n  const generate: TypeGenerator[\"generate\"] = (schema, node, options) => {\n    const generated = wrappedGenerate(schema, node, options);\n    return (\n      generated\n        .replace(\"relay-runtime\", \"@graphitation/apollo-react-relay-duct-tape\")\n        // These fields in the `@raw_response_type` output are really just for relay-runtime, so for now we can just\n        // strip them out entirely.\n        .replace(/^\\s+readonly __is[A-Z].+;\\n/gm, \"\")\n    );\n  };\n  return generate;\n}\n"],
+  "mappings": ";AAEO,SAAS,gBAAgB,iBAA4C;AAC1E,QAAM,WAAsC,CAAC,QAAQ,MAAM,YAAY;AACrE,UAAM,YAAY,gBAAgB,QAAQ,MAAM,OAAO;AACvD,WACE,UACG,QAAQ,iBAAiB,4CAA4C,EAGrE,QAAQ,iCAAiC,EAAE;AAAA,EAElD;AACA,SAAO;AACT;",
+  "names": []
+}

package/lib/types.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentNode } from "graphql";
+import type { Metadata } from "./formatModuleTransforms/extractMetadataTransform";
+export type { Metadata };
+export interface CompiledArtefactModule {
+    executionQueryDocument?: DocumentNode;
+    watchQueryDocument?: DocumentNode;
+    metadata?: Metadata;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mDAAmD,CAAC;AAElF,YAAY,EAAE,QAAQ,EAAE,CAAC;AAEzB,MAAM,WAAW,sBAAsB;IACrC,sBAAsB,CAAC,EAAE,YAAY,CAAC;IACtC,kBAAkB,CAAC,EAAE,YAAY,CAAC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB"}

package/lib/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts"],
+  "sourcesContent": ["import type { DocumentNode } from \"graphql\";\n\nimport type { Metadata } from \"./formatModuleTransforms/extractMetadataTransform\";\n\nexport type { Metadata };\n\nexport interface CompiledArtefactModule {\n  executionQueryDocument?: DocumentNode;\n  watchQueryDocument?: DocumentNode;\n  metadata?: Metadata;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/lib/types.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/typescriptTransforms/createImportDocumentsTransform.d.ts

@@ -0,0 +1,10 @@
+/**
+ * TODO:
+ * - Don't hardcode identifiers but check if they're aliased from their imports.
+ * - Support mutations and subscriptions
+ * - Properly emit errors from transformer, is invariant ok?
+ */
+import * as ts from "typescript";
+export declare function createImportDocumentsTransform(): ts.TransformerFactory<ts.SourceFile>;
+export { createImportDocumentsTransform as factory };
+//# sourceMappingURL=createImportDocumentsTransform.d.ts.map

package/lib/typescriptTransforms/createImportDocumentsTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImportDocumentsTransform.d.ts","sourceRoot":"","sources":["../../src/typescriptTransforms/createImportDocumentsTransform.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAYjC,wBAAgB,8BAA8B,IAAI,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,UAAU,CAAC,CA8CrF;AAGD,OAAO,EAAE,8BAA8B,IAAI,OAAO,EAAE,CAAC"}

package/lib/typescriptTransforms/createImportDocumentsTransform.js

@@ -0,0 +1,161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createImportDocumentsTransform_exports = {};
+__export(createImportDocumentsTransform_exports, {
+  createImportDocumentsTransform: () => createImportDocumentsTransform,
+  factory: () => createImportDocumentsTransform
+});
+module.exports = __toCommonJS(createImportDocumentsTransform_exports);
+var import_invariant = __toESM(require("invariant"));
+var ts = __toESM(require("typescript"));
+var import_graphql = require("graphql");
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+const PREFIX = "__graphitation_";
+const QUERIES_NAMESPACE = "generatedQueries";
+function createImportDocumentsTransform() {
+  return (context) => {
+    const imports = [];
+    const visitor = (node) => {
+      if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.escapedText === "graphql") {
+        const documentNodes = createGraphQLDocumentNodes(
+          node,
+          context.getCompilerOptions().module
+        );
+        if (documentNodes) {
+          const [modulePath, importStatement, replacementNode] = documentNodes;
+          const artefactFile = path.join(
+            path.dirname(node.getSourceFile().fileName),
+            modulePath.text
+          ) + ".ts";
+          const emitImport = fs.existsSync(artefactFile);
+          if (emitImport) {
+            imports.push(importStatement);
+            return replacementNode;
+          }
+        }
+      }
+      return ts.visitEachChild(node, visitor, context);
+    };
+    return (sourceFile) => {
+      const outputSourceFile = ts.visitNode(sourceFile, visitor);
+      return ts.factory.updateSourceFile(outputSourceFile, [
+        ...imports,
+        ...outputSourceFile.statements
+      ]);
+    };
+  };
+}
+function createGraphQLDocumentNodes(graphqlTagTemplateNode, moduleKind = ts.ModuleKind.ES2015) {
+  var _a;
+  const graphqlDoc = ts.isNoSubstitutionTemplateLiteral(
+    graphqlTagTemplateNode.template
+  ) ? graphqlTagTemplateNode.template.rawText : graphqlTagTemplateNode.template.head.rawText;
+  (0, import_invariant.default)(graphqlDoc, "Expected a GraphQL document");
+  const graphqlAST = (0, import_graphql.parse)(graphqlDoc);
+  const definitionNode = graphqlAST.definitions[0];
+  if (definitionNode.kind === "OperationDefinition") {
+    if (definitionNode.operation !== "query") {
+      return void 0;
+    }
+    const operationName = (_a = definitionNode.name) == null ? void 0 : _a.value;
+    (0, import_invariant.default)(operationName, "Operations are required to have a name");
+    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${operationName}`;
+    const modulePath = createModulePathNode(operationName);
+    return [
+      modulePath,
+      createImportStatement(moduleKind, namespaceName, modulePath),
+      ts.factory.createIdentifier(namespaceName)
+    ];
+  } else if (definitionNode.kind === "FragmentDefinition") {
+    const queryName = getQueryName(definitionNode);
+    const fragmentName = definitionNode.name.value;
+    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${fragmentName}`;
+    const modulePath = createModulePathNode(queryName);
+    return [
+      modulePath,
+      createImportStatement(moduleKind, namespaceName, modulePath),
+      ts.factory.createIdentifier(namespaceName)
+    ];
+  }
+  (0, import_invariant.default)(false, `Unhandled GraphQL definition type: ${definitionNode.kind}`);
+}
+function createModulePathNode(baseName) {
+  return ts.factory.createStringLiteral(`./__generated__/${baseName}.graphql`);
+}
+function createImportStatement(moduleKind, namespaceName, modulePath) {
+  if (moduleKind === ts.ModuleKind.CommonJS) {
+    return ts.factory.createVariableStatement(
+      void 0,
+      ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(
+          namespaceName,
+          void 0,
+          void 0,
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("require"),
+              [],
+              [modulePath]
+            ),
+            ts.factory.createIdentifier("documents")
+          )
+        )
+      ])
+    );
+  } else {
+    return ts.factory.createImportDeclaration(
+      void 0,
+      void 0,
+      ts.factory.createImportClause(
+        false,
+        void 0,
+        ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(
+            false,
+            ts.factory.createIdentifier("documents"),
+            ts.factory.createIdentifier(namespaceName)
+          )
+        ])
+      ),
+      modulePath
+    );
+  }
+}
+function getQueryName(definitionNode) {
+  var _a, _b, _c, _d;
+  const refetchableQueryNameNode = (_d = (_c = (_b = (_a = definitionNode.directives) == null ? void 0 : _a.find((directive) => directive.name.value === "refetchable")) == null ? void 0 : _b.arguments) == null ? void 0 : _c.find((arg) => arg.name.value === "queryName")) == null ? void 0 : _d.value;
+  if (refetchableQueryNameNode) {
+    return refetchableQueryNameNode.value;
+  } else {
+    const fragmentName = definitionNode.name.value;
+    const fragmentBaseName = fragmentName.replace(/Fragment$/, "");
+    return `${fragmentBaseName}WatchNodeQuery`;
+  }
+}

package/lib/typescriptTransforms/createImportDocumentsTransform.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/typescriptTransforms/createImportDocumentsTransform.ts"],
+  "sourcesContent": ["/**\n * TODO:\n * - Don't hardcode identifiers but check if they're aliased from their imports.\n * - Support mutations and subscriptions\n * - Properly emit errors from transformer, is invariant ok?\n */\n\nimport invariant from \"invariant\";\nimport * as ts from \"typescript\";\nimport {\n  FragmentDefinitionNode,\n  parse as parseGraphQL,\n  StringValueNode,\n} from \"graphql\";\nimport * as path from \"path\";\nimport * as fs from \"fs\";\n\nconst PREFIX = \"__graphitation_\";\nconst QUERIES_NAMESPACE = \"generatedQueries\";\n\nexport function createImportDocumentsTransform(): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    const imports: ts.Statement[] = [];\n\n    const visitor: ts.Visitor = (node: ts.Node): ts.VisitResult<ts.Node> => {\n      if (\n        ts.isTaggedTemplateExpression(node) &&\n        ts.isIdentifier(node.tag) &&\n        node.tag.escapedText === \"graphql\"\n      ) {\n        const documentNodes = createGraphQLDocumentNodes(\n          node,\n          context.getCompilerOptions().module,\n        );\n        if (documentNodes) {\n          const [modulePath, importStatement, replacementNode] = documentNodes;\n          // Because we currently only emit new watch queries for fragments\n          // on Node types, we cannot just assume the artefact exists for\n          // every fragment definition. So check if it exists before emitting\n          // the import.\n          //\n          // TODO: This file checking should not exist and is probably not\n          //       performant.\n          const artefactFile =\n            path.join(\n              path.dirname(node.getSourceFile().fileName),\n              modulePath.text,\n            ) + \".ts\";\n          const emitImport = fs.existsSync(artefactFile);\n          if (emitImport) {\n            imports.push(importStatement);\n            return replacementNode;\n          }\n        }\n      }\n      return ts.visitEachChild(node, visitor, context);\n    };\n\n    return (sourceFile: ts.SourceFile) => {\n      const outputSourceFile = ts.visitNode(sourceFile, visitor);\n      return ts.factory.updateSourceFile(outputSourceFile, [\n        ...imports,\n        ...outputSourceFile.statements,\n      ]);\n    };\n  };\n}\n\n// This is for ts-jest\nexport { createImportDocumentsTransform as factory };\n\nfunction createGraphQLDocumentNodes(\n  graphqlTagTemplateNode: ts.TaggedTemplateExpression,\n  moduleKind: ts.ModuleKind = ts.ModuleKind.ES2015,\n):\n  | [\n      modulePath: ts.StringLiteral,\n      importStatement: ts.Statement,\n      importReference: ts.Identifier,\n    ]\n  | undefined {\n  const graphqlDoc = ts.isNoSubstitutionTemplateLiteral(\n    graphqlTagTemplateNode.template,\n  )\n    ? graphqlTagTemplateNode.template.rawText\n    : graphqlTagTemplateNode.template.head.rawText;\n  invariant(graphqlDoc, \"Expected a GraphQL document\");\n  const graphqlAST = parseGraphQL(graphqlDoc);\n  const definitionNode = graphqlAST.definitions[0];\n  if (definitionNode.kind === \"OperationDefinition\") {\n    if (definitionNode.operation !== \"query\") {\n      return undefined;\n    }\n    const operationName = definitionNode.name?.value;\n    invariant(operationName, \"Operations are required to have a name\");\n    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${operationName}`;\n    const modulePath = createModulePathNode(operationName);\n    return [\n      modulePath,\n      createImportStatement(moduleKind, namespaceName, modulePath),\n      ts.factory.createIdentifier(namespaceName),\n    ];\n  } else if (definitionNode.kind === \"FragmentDefinition\") {\n    const queryName = getQueryName(definitionNode);\n    const fragmentName = definitionNode.name.value;\n    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${fragmentName}`;\n    const modulePath = createModulePathNode(queryName);\n    return [\n      modulePath,\n      createImportStatement(moduleKind, namespaceName, modulePath),\n      ts.factory.createIdentifier(namespaceName),\n    ];\n  }\n  invariant(false, `Unhandled GraphQL definition type: ${definitionNode.kind}`);\n}\n\nfunction createModulePathNode(baseName: string) {\n  return ts.factory.createStringLiteral(`./__generated__/${baseName}.graphql`);\n}\n\nfunction createImportStatement(\n  moduleKind: ts.ModuleKind,\n  namespaceName: string,\n  modulePath: ts.StringLiteral,\n): ts.Statement {\n  if (moduleKind === ts.ModuleKind.CommonJS) {\n    return ts.factory.createVariableStatement(\n      undefined,\n      ts.factory.createVariableDeclarationList([\n        ts.factory.createVariableDeclaration(\n          namespaceName,\n          undefined,\n          undefined,\n          ts.factory.createPropertyAccessExpression(\n            ts.factory.createCallExpression(\n              ts.factory.createIdentifier(\"require\"),\n              [],\n              [modulePath],\n            ),\n            ts.factory.createIdentifier(\"documents\"),\n          ),\n        ),\n      ]),\n    );\n  } else {\n    return ts.factory.createImportDeclaration(\n      undefined,\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        undefined,\n        ts.factory.createNamedImports([\n          ts.factory.createImportSpecifier(\n            false,\n            ts.factory.createIdentifier(\"documents\"),\n            ts.factory.createIdentifier(namespaceName),\n          ),\n        ]),\n      ),\n      modulePath,\n    );\n  }\n}\n\nfunction getQueryName(definitionNode: FragmentDefinitionNode) {\n  const refetchableQueryNameNode = definitionNode.directives\n    ?.find((directive) => directive.name.value === \"refetchable\")\n    ?.arguments?.find((arg) => arg.name.value === \"queryName\")?.value as\n    | StringValueNode\n    | undefined;\n  if (refetchableQueryNameNode) {\n    return refetchableQueryNameNode.value;\n  } else {\n    const fragmentName = definitionNode.name.value;\n    const fragmentBaseName = fragmentName.replace(/Fragment$/, \"\");\n    return `${fragmentBaseName}WatchNodeQuery`;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["invariant", "parseGraphQL"]
+}

package/lib/typescriptTransforms/createImportDocumentsTransform.mjs

@@ -0,0 +1,134 @@
+// src/typescriptTransforms/createImportDocumentsTransform.ts
+import invariant from "invariant";
+import * as ts from "typescript";
+import {
+  parse as parseGraphQL
+} from "graphql";
+import * as path from "path";
+import * as fs from "fs";
+var PREFIX = "__graphitation_";
+var QUERIES_NAMESPACE = "generatedQueries";
+function createImportDocumentsTransform() {
+  return (context) => {
+    const imports = [];
+    const visitor = (node) => {
+      if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.escapedText === "graphql") {
+        const documentNodes = createGraphQLDocumentNodes(
+          node,
+          context.getCompilerOptions().module
+        );
+        if (documentNodes) {
+          const [modulePath, importStatement, replacementNode] = documentNodes;
+          const artefactFile = path.join(
+            path.dirname(node.getSourceFile().fileName),
+            modulePath.text
+          ) + ".ts";
+          const emitImport = fs.existsSync(artefactFile);
+          if (emitImport) {
+            imports.push(importStatement);
+            return replacementNode;
+          }
+        }
+      }
+      return ts.visitEachChild(node, visitor, context);
+    };
+    return (sourceFile) => {
+      const outputSourceFile = ts.visitNode(sourceFile, visitor);
+      return ts.factory.updateSourceFile(outputSourceFile, [
+        ...imports,
+        ...outputSourceFile.statements
+      ]);
+    };
+  };
+}
+function createGraphQLDocumentNodes(graphqlTagTemplateNode, moduleKind = ts.ModuleKind.ES2015) {
+  var _a;
+  const graphqlDoc = ts.isNoSubstitutionTemplateLiteral(
+    graphqlTagTemplateNode.template
+  ) ? graphqlTagTemplateNode.template.rawText : graphqlTagTemplateNode.template.head.rawText;
+  invariant(graphqlDoc, "Expected a GraphQL document");
+  const graphqlAST = parseGraphQL(graphqlDoc);
+  const definitionNode = graphqlAST.definitions[0];
+  if (definitionNode.kind === "OperationDefinition") {
+    if (definitionNode.operation !== "query") {
+      return void 0;
+    }
+    const operationName = (_a = definitionNode.name) == null ? void 0 : _a.value;
+    invariant(operationName, "Operations are required to have a name");
+    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${operationName}`;
+    const modulePath = createModulePathNode(operationName);
+    return [
+      modulePath,
+      createImportStatement(moduleKind, namespaceName, modulePath),
+      ts.factory.createIdentifier(namespaceName)
+    ];
+  } else if (definitionNode.kind === "FragmentDefinition") {
+    const queryName = getQueryName(definitionNode);
+    const fragmentName = definitionNode.name.value;
+    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${fragmentName}`;
+    const modulePath = createModulePathNode(queryName);
+    return [
+      modulePath,
+      createImportStatement(moduleKind, namespaceName, modulePath),
+      ts.factory.createIdentifier(namespaceName)
+    ];
+  }
+  invariant(false, `Unhandled GraphQL definition type: ${definitionNode.kind}`);
+}
+function createModulePathNode(baseName) {
+  return ts.factory.createStringLiteral(`./__generated__/${baseName}.graphql`);
+}
+function createImportStatement(moduleKind, namespaceName, modulePath) {
+  if (moduleKind === ts.ModuleKind.CommonJS) {
+    return ts.factory.createVariableStatement(
+      void 0,
+      ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(
+          namespaceName,
+          void 0,
+          void 0,
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("require"),
+              [],
+              [modulePath]
+            ),
+            ts.factory.createIdentifier("documents")
+          )
+        )
+      ])
+    );
+  } else {
+    return ts.factory.createImportDeclaration(
+      void 0,
+      void 0,
+      ts.factory.createImportClause(
+        false,
+        void 0,
+        ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(
+            false,
+            ts.factory.createIdentifier("documents"),
+            ts.factory.createIdentifier(namespaceName)
+          )
+        ])
+      ),
+      modulePath
+    );
+  }
+}
+function getQueryName(definitionNode) {
+  var _a, _b, _c, _d;
+  const refetchableQueryNameNode = (_d = (_c = (_b = (_a = definitionNode.directives) == null ? void 0 : _a.find((directive) => directive.name.value === "refetchable")) == null ? void 0 : _b.arguments) == null ? void 0 : _c.find((arg) => arg.name.value === "queryName")) == null ? void 0 : _d.value;
+  if (refetchableQueryNameNode) {
+    return refetchableQueryNameNode.value;
+  } else {
+    const fragmentName = definitionNode.name.value;
+    const fragmentBaseName = fragmentName.replace(/Fragment$/, "");
+    return `${fragmentBaseName}WatchNodeQuery`;
+  }
+}
+export {
+  createImportDocumentsTransform,
+  createImportDocumentsTransform as factory
+};

package/lib/typescriptTransforms/createImportDocumentsTransform.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/typescriptTransforms/createImportDocumentsTransform.ts"],
+  "sourcesContent": ["/**\n * TODO:\n * - Don't hardcode identifiers but check if they're aliased from their imports.\n * - Support mutations and subscriptions\n * - Properly emit errors from transformer, is invariant ok?\n */\n\nimport invariant from \"invariant\";\nimport * as ts from \"typescript\";\nimport {\n  FragmentDefinitionNode,\n  parse as parseGraphQL,\n  StringValueNode,\n} from \"graphql\";\nimport * as path from \"path\";\nimport * as fs from \"fs\";\n\nconst PREFIX = \"__graphitation_\";\nconst QUERIES_NAMESPACE = \"generatedQueries\";\n\nexport function createImportDocumentsTransform(): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {\n    const imports: ts.Statement[] = [];\n\n    const visitor: ts.Visitor = (node: ts.Node): ts.VisitResult<ts.Node> => {\n      if (\n        ts.isTaggedTemplateExpression(node) &&\n        ts.isIdentifier(node.tag) &&\n        node.tag.escapedText === \"graphql\"\n      ) {\n        const documentNodes = createGraphQLDocumentNodes(\n          node,\n          context.getCompilerOptions().module,\n        );\n        if (documentNodes) {\n          const [modulePath, importStatement, replacementNode] = documentNodes;\n          // Because we currently only emit new watch queries for fragments\n          // on Node types, we cannot just assume the artefact exists for\n          // every fragment definition. So check if it exists before emitting\n          // the import.\n          //\n          // TODO: This file checking should not exist and is probably not\n          //       performant.\n          const artefactFile =\n            path.join(\n              path.dirname(node.getSourceFile().fileName),\n              modulePath.text,\n            ) + \".ts\";\n          const emitImport = fs.existsSync(artefactFile);\n          if (emitImport) {\n            imports.push(importStatement);\n            return replacementNode;\n          }\n        }\n      }\n      return ts.visitEachChild(node, visitor, context);\n    };\n\n    return (sourceFile: ts.SourceFile) => {\n      const outputSourceFile = ts.visitNode(sourceFile, visitor);\n      return ts.factory.updateSourceFile(outputSourceFile, [\n        ...imports,\n        ...outputSourceFile.statements,\n      ]);\n    };\n  };\n}\n\n// This is for ts-jest\nexport { createImportDocumentsTransform as factory };\n\nfunction createGraphQLDocumentNodes(\n  graphqlTagTemplateNode: ts.TaggedTemplateExpression,\n  moduleKind: ts.ModuleKind = ts.ModuleKind.ES2015,\n):\n  | [\n      modulePath: ts.StringLiteral,\n      importStatement: ts.Statement,\n      importReference: ts.Identifier,\n    ]\n  | undefined {\n  const graphqlDoc = ts.isNoSubstitutionTemplateLiteral(\n    graphqlTagTemplateNode.template,\n  )\n    ? graphqlTagTemplateNode.template.rawText\n    : graphqlTagTemplateNode.template.head.rawText;\n  invariant(graphqlDoc, \"Expected a GraphQL document\");\n  const graphqlAST = parseGraphQL(graphqlDoc);\n  const definitionNode = graphqlAST.definitions[0];\n  if (definitionNode.kind === \"OperationDefinition\") {\n    if (definitionNode.operation !== \"query\") {\n      return undefined;\n    }\n    const operationName = definitionNode.name?.value;\n    invariant(operationName, \"Operations are required to have a name\");\n    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${operationName}`;\n    const modulePath = createModulePathNode(operationName);\n    return [\n      modulePath,\n      createImportStatement(moduleKind, namespaceName, modulePath),\n      ts.factory.createIdentifier(namespaceName),\n    ];\n  } else if (definitionNode.kind === \"FragmentDefinition\") {\n    const queryName = getQueryName(definitionNode);\n    const fragmentName = definitionNode.name.value;\n    const namespaceName = `${PREFIX}${QUERIES_NAMESPACE}_${fragmentName}`;\n    const modulePath = createModulePathNode(queryName);\n    return [\n      modulePath,\n      createImportStatement(moduleKind, namespaceName, modulePath),\n      ts.factory.createIdentifier(namespaceName),\n    ];\n  }\n  invariant(false, `Unhandled GraphQL definition type: ${definitionNode.kind}`);\n}\n\nfunction createModulePathNode(baseName: string) {\n  return ts.factory.createStringLiteral(`./__generated__/${baseName}.graphql`);\n}\n\nfunction createImportStatement(\n  moduleKind: ts.ModuleKind,\n  namespaceName: string,\n  modulePath: ts.StringLiteral,\n): ts.Statement {\n  if (moduleKind === ts.ModuleKind.CommonJS) {\n    return ts.factory.createVariableStatement(\n      undefined,\n      ts.factory.createVariableDeclarationList([\n        ts.factory.createVariableDeclaration(\n          namespaceName,\n          undefined,\n          undefined,\n          ts.factory.createPropertyAccessExpression(\n            ts.factory.createCallExpression(\n              ts.factory.createIdentifier(\"require\"),\n              [],\n              [modulePath],\n            ),\n            ts.factory.createIdentifier(\"documents\"),\n          ),\n        ),\n      ]),\n    );\n  } else {\n    return ts.factory.createImportDeclaration(\n      undefined,\n      undefined,\n      ts.factory.createImportClause(\n        false,\n        undefined,\n        ts.factory.createNamedImports([\n          ts.factory.createImportSpecifier(\n            false,\n            ts.factory.createIdentifier(\"documents\"),\n            ts.factory.createIdentifier(namespaceName),\n          ),\n        ]),\n      ),\n      modulePath,\n    );\n  }\n}\n\nfunction getQueryName(definitionNode: FragmentDefinitionNode) {\n  const refetchableQueryNameNode = definitionNode.directives\n    ?.find((directive) => directive.name.value === \"refetchable\")\n    ?.arguments?.find((arg) => arg.name.value === \"queryName\")?.value as\n    | StringValueNode\n    | undefined;\n  if (refetchableQueryNameNode) {\n    return refetchableQueryNameNode.value;\n  } else {\n    const fragmentName = definitionNode.name.value;\n    const fragmentBaseName = fragmentName.replace(/Fragment$/, \"\");\n    return `${fragmentBaseName}WatchNodeQuery`;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/typings.d.js

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

package/lib/typings.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/typings.d.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}