@gql.tada/cli-utils 1.2.0 → 1.2.1-canary-e42804ea2a1e64b58239cd45b152b047b9afcd17

package/dist/chunks/thread-chunk.mjs

@@ -1,14 +1,10 @@
-import * as e from "node:path";
+import e from "typescript";
 
-import { ts as i, Project as n } from "ts-morph";
+import { findAllPersistedCallExpressions as i, getDocumentReferenceFromDocumentNode as n, getDocumentReferenceFromTypeQuery as t, unrollTadaFragments as a } from "@0no-co/graphqlsp/api";
 
-import { init as t, findAllPersistedCallExpressions as r, getDocumentReferenceFromDocumentNode as a, getDocumentReferenceFromTypeQuery as l, unrollTadaFragments as s } from "@0no-co/graphqlsp/api";
+import { e as r, p as l } from "./index-chunk.mjs";
 
-import { e as o, l as u, g as c } from "./index-chunk.mjs";
-
-import { c as m } from "./project-chunk.mjs";
-
-var v = function(e) {
+var s = function(e) {
   e[e.Const = 1] = "Const";
   e[e.Var = 2] = "Var";
   e[e.Int = 3] = "Int";
@@ -17,28 +13,28 @@ var v = function(e) {
   e[e.String = 6] = "String";
   e[e.Enum = 7] = "Enum";
   return e;
-}(v || {});
+}(s || {});
 
-var f = function(e) {
+var o = function(e) {
   e[e.Spread = 1] = "Spread";
   e[e.Name = 2] = "Name";
   return e;
-}(f || {});
+}(o || {});
 
 function mapJoin(e, i, n) {
   var t = "";
-  for (var r = 0; r < e.length; r++) {
-    if (r) {
+  for (var a = 0; a < e.length; a++) {
+    if (a) {
       t += i;
     }
-    t += n(e[r]);
+    t += n(e[a]);
   }
   return t;
 }
 
-var g = "\n";
+var u = "\n";
 
-var p = {
+var c = {
   OperationDefinition(e) {
     var i = e.operation;
     if (e.name) {
@@ -48,38 +44,38 @@ var p = {
       if (!e.name) {
         i += " ";
       }
-      i += "(" + mapJoin(e.variableDefinitions, ", ", p.VariableDefinition) + ")";
+      i += "(" + mapJoin(e.variableDefinitions, ", ", c.VariableDefinition) + ")";
     }
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
-    return "query" !== i ? i + " " + p.SelectionSet(e.selectionSet) : p.SelectionSet(e.selectionSet);
+    return "query" !== i ? i + " " + c.SelectionSet(e.selectionSet) : c.SelectionSet(e.selectionSet);
   },
   VariableDefinition(e) {
-    var i = p.Variable(e.variable) + ": " + _print(e.type);
+    var i = c.Variable(e.variable) + ": " + _print(e.type);
     if (e.defaultValue) {
       i += " = " + _print(e.defaultValue);
     }
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
     return i;
   },
   Field(e) {
     var i = e.alias ? e.alias.value + ": " + e.name.value : e.name.value;
     if (e.arguments && e.arguments.length) {
-      var n = mapJoin(e.arguments, ", ", p.Argument);
+      var n = mapJoin(e.arguments, ", ", c.Argument);
       if (i.length + n.length + 2 > 80) {
-        i += "(" + (g += "  ") + mapJoin(e.arguments, g, p.Argument) + (g = g.slice(0, -2)) + ")";
+        i += "(" + (u += "  ") + mapJoin(e.arguments, u, c.Argument) + (u = u.slice(0, -2)) + ")";
       } else {
         i += "(" + n + ")";
       }
     }
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
     if (e.selectionSet) {
-      i += " " + p.SelectionSet(e.selectionSet);
+      i += " " + c.SelectionSet(e.selectionSet);
     }
     return i;
   },
@@ -87,7 +83,7 @@ var p = {
     if (e.block) {
       return function printBlockString(e) {
         return '"""\n' + e.replace(/"""/g, '\\"""') + '\n"""';
-      }(e.value).replace(/\n/g, g);
+      }(e.value).replace(/\n/g, u);
     } else {
       return function printString(e) {
         return JSON.stringify(e);
@@ -102,7 +98,7 @@ var p = {
   Name: e => e.value,
   Variable: e => "$" + e.name.value,
   ListValue: e => "[" + mapJoin(e.values, ", ", _print) + "]",
-  ObjectValue: e => "{" + mapJoin(e.fields, ", ", p.ObjectField) + "}",
+  ObjectValue: e => "{" + mapJoin(e.fields, ", ", c.ObjectField) + "}",
   ObjectField: e => e.name.value + ": " + _print(e.value),
   Document(e) {
     if (!e.definitions || !e.definitions.length) {
@@ -110,12 +106,12 @@ var p = {
     }
     return mapJoin(e.definitions, "\n\n", _print);
   },
-  SelectionSet: e => "{" + (g += "  ") + mapJoin(e.selections, g, _print) + (g = g.slice(0, -2)) + "}",
+  SelectionSet: e => "{" + (u += "  ") + mapJoin(e.selections, u, _print) + (u = u.slice(0, -2)) + "}",
   Argument: e => e.name.value + ": " + _print(e.value),
   FragmentSpread(e) {
     var i = "..." + e.name.value;
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
     return i;
   },
@@ -125,22 +121,22 @@ var p = {
       i += " on " + e.typeCondition.name.value;
     }
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
-    return i + " " + p.SelectionSet(e.selectionSet);
+    return i + " " + c.SelectionSet(e.selectionSet);
   },
   FragmentDefinition(e) {
     var i = "fragment " + e.name.value;
     i += " on " + e.typeCondition.name.value;
     if (e.directives && e.directives.length) {
-      i += " " + mapJoin(e.directives, " ", p.Directive);
+      i += " " + mapJoin(e.directives, " ", c.Directive);
     }
-    return i + " " + p.SelectionSet(e.selectionSet);
+    return i + " " + c.SelectionSet(e.selectionSet);
   },
   Directive(e) {
     var i = "@" + e.name.value;
     if (e.arguments && e.arguments.length) {
-      i += "(" + mapJoin(e.arguments, ", ", p.Argument) + ")";
+      i += "(" + mapJoin(e.arguments, ", ", c.Argument) + ")";
     }
     return i;
   },
@@ -149,110 +145,102 @@ var p = {
   NonNullType: e => _print(e.type) + "!"
 };
 
-var _print = e => p[e.kind](e);
+var _print = e => c[e.kind](e);
 
 function print(e) {
-  g = "\n";
-  return p[e.kind] ? p[e.kind](e) : "";
+  u = "\n";
+  return c[e.kind] ? c[e.kind](e) : "";
 }
 
-var d = o((async function* _runPersisted(o) {
-  t({
-    typescript: i
-  });
-  var v = e.dirname(o.configPath);
-  var f = new n({
-    tsConfigFilePath: o.configPath
-  });
-  var g = await u(v, f, i);
-  if (g) {
+var m = r((async function* _runPersisted(r) {
+  var s = l(r);
+  var o = s.createExternalFiles();
+  if (o.length) {
     yield {
       kind: "EXTERNAL_WARNING"
     };
+    await s.addVirtualFiles(o);
   }
-  var p = m(f, o.pluginConfig, v, g);
-  var d = f.getSourceFiles().filter((i => {
-    var n = e.resolve(v, i.getFilePath());
-    return !e.relative(o.rootPath, n).startsWith("..");
-  }));
+  var u = s.build();
+  var c = u.getSourceFiles();
   yield {
     kind: "FILE_COUNT",
-    fileCount: d.length
+    fileCount: c.length
   };
-  for (var {compilerNode: h} of d) {
-    var S = h.fileName;
-    var y = {};
-    var N = [];
-    var b = r(h);
-    for (var D of b) {
-      var J = c(h, D.getStart(), void 0, g);
-      S = J.file;
-      var V = D.arguments[0];
-      var F = D.arguments[1];
-      var T = D.typeArguments && D.typeArguments[0];
-      if (!V || !i.isStringLiteral(V)) {
-        N.push({
+  for (var m of c) {
+    var f = m.fileName;
+    var v = {};
+    var g = [];
+    var d = i(m);
+    for (var p of d) {
+      var S = u.getSourcePosition(m, p.getStart());
+      f = S.fileName;
+      var h = p.arguments[0];
+      var y = p.arguments[1];
+      var N = p.typeArguments && p.typeArguments[0];
+      if (!h || !e.isStringLiteral(h)) {
+        g.push({
           message: '"graphql.persisted" must be called with a string literal as the first argument.',
-          file: J.file,
-          line: J.line,
-          col: J.col
+          file: S.fileName,
+          line: S.line,
+          col: S.col
         });
         continue;
-      } else if (!F && !T) {
-        N.push({
+      } else if (!y && !N) {
+        g.push({
           message: '"graphql.persisted" is missing a document.\nThis may be passed as a generic such as `graphql.persisted<typeof document>` or as the second argument.',
-          file: J.file,
-          line: J.line,
-          col: J.col
+          file: S.fileName,
+          line: S.line,
+          col: S.col
         });
         continue;
       }
-      var k = null;
-      var C = D;
-      if (F && (i.isCallExpression(F) || i.isIdentifier(F))) {
-        k = a(F, h.fileName, p).node;
-        C = F;
-      } else if (T && i.isTypeQueryNode(T)) {
-        k = l(T, h.fileName, p).node;
-        C = T;
+      var b = null;
+      var V = p;
+      if (y && (e.isCallExpression(y) || e.isIdentifier(y))) {
+        b = n(y, m.fileName, u.buildPluginInfo(r.pluginConfig)).node;
+        V = y;
+      } else if (N && e.isTypeQueryNode(N)) {
+        b = t(N, m.fileName, u.buildPluginInfo(r.pluginConfig)).node;
+        V = N;
       }
-      if (!k) {
-        N.push({
-          message: `Could not find reference for "${C.getText()}".\nIf this is unexpected, please file an issue describing your case.`,
-          file: J.file,
-          line: J.line,
-          col: J.col
+      if (!b) {
+        g.push({
+          message: `Could not find reference for "${V.getText()}".\nIf this is unexpected, please file an issue describing your case.`,
+          file: S.fileName,
+          line: S.line,
+          col: S.col
         });
         continue;
       }
-      if (!k || !i.isCallExpression(k) || !i.isNoSubstitutionTemplateLiteral(k.arguments[0]) && !i.isStringLiteral(k.arguments[0])) {
-        N.push({
-          message: `The referenced document of "${C.getText()}" contains no document string literal.\nIf this is unexpected, please file an issue describing your case.`,
-          file: J.file,
-          line: J.line,
-          col: J.col
+      if (!b || !e.isCallExpression(b) || !e.isNoSubstitutionTemplateLiteral(b.arguments[0]) && !e.isStringLiteral(b.arguments[0])) {
+        g.push({
+          message: `The referenced document of "${V.getText()}" contains no document string literal.\nIf this is unexpected, please file an issue describing your case.`,
+          file: S.fileName,
+          line: S.line,
+          col: S.col
         });
         continue;
       }
-      var E = [];
-      var x = k.arguments[0].getText().slice(1, -1);
-      if (k.arguments[1] && i.isArrayLiteralExpression(k.arguments[1])) {
-        s(k.arguments[1], E, p);
+      var D = [];
+      var J = b.arguments[0].getText().slice(1, -1);
+      if (b.arguments[1] && e.isArrayLiteralExpression(b.arguments[1])) {
+        a(b.arguments[1], D, u.buildPluginInfo(r.pluginConfig));
       }
-      var I = x;
-      for (var A of E) {
-        I += "\n\n" + print(A);
+      var F = J;
+      for (var I of D) {
+        F += "\n\n" + print(I);
       }
-      y[V.getText().slice(1, -1)] = I;
+      v[h.getText().slice(1, -1)] = F;
     }
     yield {
       kind: "FILE_PERSISTED",
-      filePath: S,
-      documents: y,
-      warnings: N
+      filePath: f,
+      documents: v,
+      warnings: g
     };
   }
 }));
 
-export { d as runPersisted };
+export { m as runPersisted };
 //# sourceMappingURL=thread-chunk.mjs.map

package/dist/chunks/thread-chunk.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"thread-chunk.mjs","sources":["../../src/commands/generate-persisted/thread.ts"],"sourcesContent":["import * as path from 'node:path';\nimport { print } from '@0no-co/graphql.web';\nimport { Project, ts } from 'ts-morph';\n\nimport type { FragmentDefinitionNode } from '@0no-co/graphql.web';\nimport type { GraphQLSPConfig } from '@gql.tada/internal';\n\nimport {\n  init,\n  findAllPersistedCallExpressions,\n  getDocumentReferenceFromTypeQuery,\n  getDocumentReferenceFromDocumentNode,\n  unrollTadaFragments,\n} from '@0no-co/graphqlsp/api';\n\nimport { createPluginInfo, getFilePosition, loadVirtualCode } from '../../ts';\nimport { expose } from '../../threads';\n\nimport type { PersistedSignal, PersistedWarning } from './types';\n\nexport interface PersistedParams {\n  rootPath: string;\n  configPath: string;\n  pluginConfig: GraphQLSPConfig;\n}\n\nasync function* _runPersisted(params: PersistedParams): AsyncIterableIterator<PersistedSignal> {\n  init({ typescript: ts });\n\n  const projectPath = path.dirname(params.configPath);\n  const project = new Project({ tsConfigFilePath: params.configPath });\n\n  const getVirtualPosition = await loadVirtualCode(projectPath, project, ts);\n  if (!!getVirtualPosition) {\n    yield { kind: 'EXTERNAL_WARNING' };\n  }\n\n  const pluginInfo = createPluginInfo(\n    project,\n    params.pluginConfig,\n    projectPath,\n    getVirtualPosition\n  );\n\n  // Filter source files by whether they're under the relevant root path\n  const sourceFiles = project.getSourceFiles().filter((sourceFile) => {\n    const filePath = path.resolve(projectPath, sourceFile.getFilePath());\n    const relative = path.relative(params.rootPath, filePath);\n    return !relative.startsWith('..');\n  });\n\n  yield {\n    kind: 'FILE_COUNT',\n    fileCount: sourceFiles.length,\n  };\n\n  for (const { compilerNode: sourceFile } of sourceFiles) {\n    let filePath = sourceFile.fileName;\n    const documents: Record<string, string> = {};\n    const warnings: PersistedWarning[] = [];\n\n    const calls = findAllPersistedCallExpressions(sourceFile);\n    for (const call of calls) {\n      const position = getFilePosition(sourceFile, call.getStart(), undefined, getVirtualPosition);\n      filePath = position.file;\n\n      const hashArg = call.arguments[0];\n      const docArg = call.arguments[1];\n      const typeQuery = call.typeArguments && call.typeArguments[0];\n      if (!hashArg || !ts.isStringLiteral(hashArg)) {\n        warnings.push({\n          message:\n            '\"graphql.persisted\" must be called with a string literal as the first argument.',\n          file: position.file,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      } else if (!docArg && !typeQuery) {\n        warnings.push({\n          message:\n            '\"graphql.persisted\" is missing a document.\\n' +\n            'This may be passed as a generic such as `graphql.persisted<typeof document>` or as the second argument.',\n          file: position.file,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      let foundNode: ts.CallExpression | null = null;\n      let referencingNode: ts.Node = call;\n      if (docArg && (ts.isCallExpression(docArg) || ts.isIdentifier(docArg))) {\n        const result = getDocumentReferenceFromDocumentNode(\n          docArg,\n          sourceFile.fileName,\n          pluginInfo\n        );\n        foundNode = result.node;\n        referencingNode = docArg;\n      } else if (typeQuery && ts.isTypeQueryNode(typeQuery)) {\n        const result = getDocumentReferenceFromTypeQuery(\n          typeQuery,\n          sourceFile.fileName,\n          pluginInfo\n        );\n        foundNode = result.node;\n        referencingNode = typeQuery;\n      }\n\n      if (!foundNode) {\n        warnings.push({\n          message:\n            `Could not find reference for \"${referencingNode.getText()}\".\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.file,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      if (\n        !foundNode ||\n        !ts.isCallExpression(foundNode) ||\n        (!ts.isNoSubstitutionTemplateLiteral(foundNode.arguments[0]) &&\n          !ts.isStringLiteral(foundNode.arguments[0]))\n      ) {\n        warnings.push({\n          message:\n            `The referenced document of \"${referencingNode.getText()}\" contains no document string literal.\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.file,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      const fragments: FragmentDefinitionNode[] = [];\n      const operation = foundNode.arguments[0].getText().slice(1, -1);\n      if (foundNode.arguments[1] && ts.isArrayLiteralExpression(foundNode.arguments[1])) {\n        unrollTadaFragments(foundNode.arguments[1], fragments, pluginInfo);\n      }\n\n      let document = operation;\n      for (const fragment of fragments) document += '\\n\\n' + print(fragment);\n      documents[hashArg.getText().slice(1, -1)] = document;\n    }\n\n    yield {\n      kind: 'FILE_PERSISTED',\n      filePath,\n      documents,\n      warnings,\n    };\n  }\n}\n\nexport const runPersisted = expose(_runPersisted);\n"],"names":["runPersisted","expose","async","_runPersisted","params","init","typescript","ts","projectPath","path","dirname","configPath","project","Project","tsConfigFilePath","getVirtualPosition","loadVirtualCode","kind","pluginInfo","createPluginInfo","pluginConfig","sourceFiles","getSourceFiles","filter","sourceFile","filePath","resolve","getFilePath","relative","rootPath","startsWith","fileCount","length","compilerNode","fileName","documents","warnings","calls","findAllPersistedCallExpressions","call","position","getFilePosition","getStart","undefined","file","hashArg","arguments","docArg","typeQuery","typeArguments","isStringLiteral","push","message","line","col","foundNode","referencingNode","isCallExpression","isIdentifier","getDocumentReferenceFromDocumentNode","node","isTypeQueryNode","getDocumentReferenceFromTypeQuery","getText","isNoSubstitutionTemplateLiteral","fragments","operation","slice","isArrayLiteralExpression","unrollTadaFragments","document","fragment","print"],"mappings":"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"}
+{"version":3,"file":"thread-chunk.mjs","sources":["../../src/commands/generate-persisted/thread.ts"],"sourcesContent":["import ts from 'typescript';\nimport { print } from '@0no-co/graphql.web';\n\nimport type { FragmentDefinitionNode } from '@0no-co/graphql.web';\nimport type { GraphQLSPConfig } from '@gql.tada/internal';\n\nimport {\n  findAllPersistedCallExpressions,\n  getDocumentReferenceFromTypeQuery,\n  getDocumentReferenceFromDocumentNode,\n  unrollTadaFragments,\n} from '@0no-co/graphqlsp/api';\n\nimport { programFactory } from '../../ts';\nimport { expose } from '../../threads';\n\nimport type { PersistedSignal, PersistedWarning } from './types';\n\nexport interface PersistedParams {\n  rootPath: string;\n  configPath: string;\n  pluginConfig: GraphQLSPConfig;\n}\n\nasync function* _runPersisted(params: PersistedParams): AsyncIterableIterator<PersistedSignal> {\n  const factory = programFactory(params);\n\n  const externalFiles = factory.createExternalFiles();\n  if (externalFiles.length) {\n    yield { kind: 'EXTERNAL_WARNING' };\n    await factory.addVirtualFiles(externalFiles);\n  }\n\n  const container = factory.build();\n  const sourceFiles = container.getSourceFiles();\n\n  yield {\n    kind: 'FILE_COUNT',\n    fileCount: sourceFiles.length,\n  };\n\n  for (const sourceFile of sourceFiles) {\n    let filePath = sourceFile.fileName;\n    const documents: Record<string, string> = {};\n    const warnings: PersistedWarning[] = [];\n\n    const calls = findAllPersistedCallExpressions(sourceFile);\n    for (const call of calls) {\n      const position = container.getSourcePosition(sourceFile, call.getStart());\n      filePath = position.fileName;\n\n      const hashArg = call.arguments[0];\n      const docArg = call.arguments[1];\n      const typeQuery = call.typeArguments && call.typeArguments[0];\n      if (!hashArg || !ts.isStringLiteral(hashArg)) {\n        warnings.push({\n          message:\n            '\"graphql.persisted\" must be called with a string literal as the first argument.',\n          file: position.fileName,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      } else if (!docArg && !typeQuery) {\n        warnings.push({\n          message:\n            '\"graphql.persisted\" is missing a document.\\n' +\n            'This may be passed as a generic such as `graphql.persisted<typeof document>` or as the second argument.',\n          file: position.fileName,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      let foundNode: ts.CallExpression | null = null;\n      let referencingNode: ts.Node = call;\n      if (docArg && (ts.isCallExpression(docArg) || ts.isIdentifier(docArg))) {\n        const result = getDocumentReferenceFromDocumentNode(\n          docArg,\n          sourceFile.fileName,\n          container.buildPluginInfo(params.pluginConfig)\n        );\n        foundNode = result.node;\n        referencingNode = docArg;\n      } else if (typeQuery && ts.isTypeQueryNode(typeQuery)) {\n        const result = getDocumentReferenceFromTypeQuery(\n          typeQuery,\n          sourceFile.fileName,\n          container.buildPluginInfo(params.pluginConfig)\n        );\n        foundNode = result.node;\n        referencingNode = typeQuery;\n      }\n\n      if (!foundNode) {\n        warnings.push({\n          message:\n            `Could not find reference for \"${referencingNode.getText()}\".\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.fileName,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      if (\n        !foundNode ||\n        !ts.isCallExpression(foundNode) ||\n        (!ts.isNoSubstitutionTemplateLiteral(foundNode.arguments[0]) &&\n          !ts.isStringLiteral(foundNode.arguments[0]))\n      ) {\n        warnings.push({\n          message:\n            `The referenced document of \"${referencingNode.getText()}\" contains no document string literal.\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.fileName,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      const fragments: FragmentDefinitionNode[] = [];\n      const operation = foundNode.arguments[0].getText().slice(1, -1);\n      if (foundNode.arguments[1] && ts.isArrayLiteralExpression(foundNode.arguments[1])) {\n        unrollTadaFragments(\n          foundNode.arguments[1],\n          fragments,\n          container.buildPluginInfo(params.pluginConfig)\n        );\n      }\n\n      let document = operation;\n      for (const fragment of fragments) document += '\\n\\n' + print(fragment);\n      documents[hashArg.getText().slice(1, -1)] = document;\n    }\n\n    yield {\n      kind: 'FILE_PERSISTED',\n      filePath,\n      documents,\n      warnings,\n    };\n  }\n}\n\nexport const runPersisted = expose(_runPersisted);\n"],"names":["runPersisted","expose","async","_runPersisted","params","factory","programFactory","externalFiles","createExternalFiles","length","kind","addVirtualFiles","container","build","sourceFiles","getSourceFiles","fileCount","sourceFile","filePath","fileName","documents","warnings","calls","findAllPersistedCallExpressions","call","position","getSourcePosition","getStart","hashArg","arguments","docArg","typeQuery","typeArguments","ts","isStringLiteral","push","message","file","line","col","foundNode","referencingNode","isCallExpression","isIdentifier","getDocumentReferenceFromDocumentNode","buildPluginInfo","pluginConfig","node","isTypeQueryNode","getDocumentReferenceFromTypeQuery","getText","isNoSubstitutionTemplateLiteral","fragments","operation","slice","isArrayLiteralExpression","unrollTadaFragments","document","fragment","print"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoJaA,IAAeC,GA5H5BC,gBAAgBC,cAAcC;EAC5B,IAAMC,IAAUC,EAAeF;EAE/B,IAAMG,IAAgBF,EAAQG;EAC9B,IAAID,EAAcE,QAAQ;UAClB;MAAEC,MAAM;;UACRL,EAAQM,gBAAgBJ;AAChC;EAEA,IAAMK,IAAYP,EAAQQ;EAC1B,IAAMC,IAAcF,EAAUG;QAExB;IACJL,MAAM;IACNM,WAAWF,EAAYL;;EAGzB,KAAK,IAAMQ,KAAcH,GAAa;IACpC,IAAII,IAAWD,EAAWE;IAC1B,IAAMC,IAAoC,CAAA;IAC1C,IAAMC,IAA+B;IAErC,IAAMC,IAAQC,EAAgCN;IAC9C,KAAK,IAAMO,KAAQF,GAAO;MACxB,IAAMG,IAAWb,EAAUc,kBAAkBT,GAAYO,EAAKG;MAC9DT,IAAWO,EAASN;MAEpB,IAAMS,IAAUJ,EAAKK,UAAU;MAC/B,IAAMC,IAASN,EAAKK,UAAU;MAC9B,IAAME,IAAYP,EAAKQ,iBAAiBR,EAAKQ,cAAc;MAC3D,KAAKJ,MAAYK,EAAGC,gBAAgBN,IAAU;QAC5CP,EAASc,KAAK;UACZC,SACE;UACFC,MAAMZ,EAASN;UACfmB,MAAMb,EAASa;UACfC,KAAKd,EAASc;;QAEhB;AACF,aAAO,KAAKT,MAAWC,GAAW;QAChCV,EAASc,KAAK;UACZC,SACE;UAEFC,MAAMZ,EAASN;UACfmB,MAAMb,EAASa;UACfC,KAAKd,EAASc;;QAEhB;AACF;MAEA,IAAIC,IAAsC;MAC1C,IAAIC,IAA2BjB;MAC/B,IAAIM,MAAWG,EAAGS,iBAAiBZ,MAAWG,EAAGU,aAAab,KAAU;QAMtEU,IALeI,EACbd,GACAb,EAAWE,UACXP,EAAUiC,gBAAgBzC,EAAO0C,eAEhBC;QACnBN,IAAkBX;AACnB,aAAM,IAAIC,KAAaE,EAAGe,gBAAgBjB,IAAY;QAMrDS,IALeS,EACblB,GACAd,EAAWE,UACXP,EAAUiC,gBAAgBzC,EAAO0C,eAEhBC;QACnBN,IAAkBV;AACpB;MAEA,KAAKS,GAAW;QACdnB,EAASc,KAAK;UACZC,SACG,iCAAgCK,EAAgBS;UAEnDb,MAAMZ,EAASN;UACfmB,MAAMb,EAASa;UACfC,KAAKd,EAASc;;QAEhB;AACF;MAEA,KACGC,MACAP,EAAGS,iBAAiBF,OACnBP,EAAGkB,gCAAgCX,EAAUX,UAAU,QACtDI,EAAGC,gBAAgBM,EAAUX,UAAU,KAC1C;QACAR,EAASc,KAAK;UACZC,SACG,+BAA8BK,EAAgBS;UAEjDb,MAAMZ,EAASN;UACfmB,MAAMb,EAASa;UACfC,KAAKd,EAASc;;QAEhB;AACF;MAEA,IAAMa,IAAsC;MAC5C,IAAMC,IAAYb,EAAUX,UAAU,GAAGqB,UAAUI,MAAM,IAAI;MAC7D,IAAId,EAAUX,UAAU,MAAMI,EAAGsB,yBAAyBf,EAAUX,UAAU;QAC5E2B,EACEhB,EAAUX,UAAU,IACpBuB,GACAxC,EAAUiC,gBAAgBzC,EAAO0C;;MAIrC,IAAIW,IAAWJ;MACf,KAAK,IAAMK,KAAYN;QAAWK,KAAY,SAASE,MAAMD;;MAC7DtC,EAAUQ,EAAQsB,UAAUI,MAAM,IAAI,MAAMG;AAC9C;UAEM;MACJ/C,MAAM;MACNQ;MACAE;MACAC;;AAEJ;AACF;;"}

package/dist/chunks/thread-chunk2.js

@@ -1,111 +1,75 @@
-var e = require("node:path");
+var e = require("typescript");
 
-var r = require("ts-morph");
+var a = require("./index-chunk.js");
 
-var a = require("@0no-co/graphqlsp/api");
-
-var t = require("./index-chunk.js");
-
-function _interopNamespaceDefault(e) {
-  var r = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach((function(a) {
-      if ("default" !== a) {
-        var t = Object.getOwnPropertyDescriptor(e, a);
-        Object.defineProperty(r, a, t.get ? t : {
-          enumerable: !0,
-          get: function() {
-            return e[a];
-          }
-        });
-      }
-    }));
-  }
-  r.default = e;
-  return r;
-}
-
-var i = _interopNamespaceDefault(e);
-
-var n = t.expose((async function* _runTurbo(e) {
-  a.init({
-    typescript: r.ts
-  });
-  var n = i.dirname(e.configPath);
-  var s = new r.Project({
-    tsConfigFilePath: e.configPath,
-    skipAddingFilesFromTsConfig: !0
+var r = a.expose((async function* _runTurbo(r) {
+  var n = a.programFactory(r);
+  n.addSourceFile({
+    fileId: "__gql-tada-override__.d.ts",
+    sourceText: t,
+    scriptKind: e.ScriptKind.TS
   });
-  var c = s.createSourceFile("__gql-tada-override__.d.ts", l, {
-    overwrite: !0,
-    scriptKind: r.ScriptKind.TS
-  });
-  if (c._markAsInProject) {
-    c._markAsInProject();
-  }
-  s.addSourceFilesFromTsConfig(e.configPath);
-  var p = await t.loadVirtualCode(n, s, r.ts);
-  if (p) {
+  var l = n.createExternalFiles();
+  if (l.length) {
     yield {
       kind: "EXTERNAL_WARNING"
     };
+    await n.addVirtualFiles(l);
   }
-  var u = s.getSourceFiles().filter((r => {
-    var a = i.resolve(n, r.getFilePath());
-    return !i.relative(e.rootPath, a).startsWith("..");
-  }));
+  var o = n.build();
+  var s = o.getSourceFiles();
   yield {
     kind: "FILE_COUNT",
-    fileCount: u.length
+    fileCount: s.length
   };
-  var d = s.getTypeChecker().compilerObject;
-  for (var {compilerNode: f} of u) {
-    var g = f.fileName;
-    var m = {};
-    var v = [];
-    var y = findAllCallExpressions(f, e.pluginConfig);
-    for (var T of y) {
-      var F = d.getTypeAtLocation(T);
-      var h = d.getTypeAtLocation(T.arguments[0]);
-      if (!F.symbol || "TadaDocumentNode" !== F.symbol.getEscapedName()) {
-        var S = t.getFilePosition(f, T.getStart(), void 0, p);
-        g = S.file;
-        v.push({
+  var d = o.program.getTypeChecker();
+  for (var p of s) {
+    var u = p.fileName;
+    var g = {};
+    var c = [];
+    var f = findAllCallExpressions(p, r.pluginConfig);
+    for (var y of f) {
+      var T = d.getTypeAtLocation(y);
+      var m = d.getTypeAtLocation(y.arguments[0]);
+      if (!T.symbol || "TadaDocumentNode" !== T.symbol.getEscapedName()) {
+        var v = o.getSourcePosition(p, y.getStart());
+        u = v.fileName;
+        c.push({
           message: 'The discovered document is not of type "TadaDocumentNode".\nIf this is unexpected, please file an issue describing your case.',
-          file: S.file,
-          line: S.line,
-          col: S.col
+          file: v.fileName,
+          line: v.line,
+          col: v.col
         });
         continue;
       }
-      m["value" in h && "string" == typeof h.value && 0 == (h.flags & r.TypeFlags.StringLiteral) ? JSON.stringify(h.value) : d.typeToString(h, T, o)] = d.typeToString(F, T, o);
+      g["value" in m && "string" == typeof m.value && 0 == (m.flags & e.TypeFlags.StringLiteral) ? JSON.stringify(m.value) : d.typeToString(m, y, i)] = d.typeToString(T, y, i);
     }
     yield {
       kind: "FILE_TURBO",
-      filePath: g,
-      cache: m,
-      warnings: v
+      filePath: u,
+      cache: g,
+      warnings: c
     };
   }
 }));
 
-var o = r.TypeFormatFlags.NoTruncation | r.TypeFormatFlags.NoTypeReduction | r.TypeFormatFlags.InTypeAlias | r.TypeFormatFlags.UseFullyQualifiedType | r.TypeFormatFlags.GenerateNamesForShadowedTypeParams | r.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | r.TypeFormatFlags.AllowUniqueESSymbolType | r.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+var i = e.TypeFormatFlags.NoTruncation | e.TypeFormatFlags.NoTypeReduction | e.TypeFormatFlags.InTypeAlias | e.TypeFormatFlags.UseFullyQualifiedType | e.TypeFormatFlags.GenerateNamesForShadowedTypeParams | e.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | e.TypeFormatFlags.AllowUniqueESSymbolType | e.TypeFormatFlags.WriteTypeArgumentsOfSignature;
 
-var l = "\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n".trim();
+var t = "\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n".trim();
 
-function findAllCallExpressions(e, a) {
-  var t = [];
-  var i = new Set([ a.template, "graphql", "gql" ].filter(Boolean));
-  !function find(e) {
-    if (r.ts.isCallExpression(e) && i.has(e.expression.getText())) {
-      t.push(e);
+function findAllCallExpressions(a, r) {
+  var i = [];
+  var t = new Set([ r.template, "graphql", "gql" ].filter(Boolean));
+  !function find(a) {
+    if (e.isCallExpression(a) && t.has(a.expression.getText())) {
+      i.push(a);
       return;
     } else {
-      r.ts.forEachChild(e, find);
+      e.forEachChild(a, find);
     }
-  }(e);
-  return t;
+  }(a);
+  return i;
 }
 
-exports.runTurbo = n;
+exports.runTurbo = r;
 //# sourceMappingURL=thread-chunk2.js.map

package/dist/chunks/thread-chunk2.js.map

@@ -1 +1 @@
-{"version":3,"file":"thread-chunk2.js","sources":["../../src/commands/turbo/thread.ts"],"sourcesContent":["import * as path from 'node:path';\nimport { Project, TypeFormatFlags, TypeFlags, ScriptKind, ts } from 'ts-morph';\n\nimport type { GraphQLSPConfig } from '@gql.tada/internal';\nimport { init } from '@0no-co/graphqlsp/api';\n\nimport { getFilePosition, loadVirtualCode } from '../../ts';\nimport { expose } from '../../threads';\n\nimport type { TurboSignal, TurboWarning } from './types';\n\nexport interface TurboParams {\n  rootPath: string;\n  configPath: string;\n  pluginConfig: GraphQLSPConfig;\n}\n\nasync function* _runTurbo(params: TurboParams): AsyncIterableIterator<TurboSignal> {\n  init({ typescript: ts });\n\n  const projectPath = path.dirname(params.configPath);\n  const project = new Project({\n    tsConfigFilePath: params.configPath,\n    skipAddingFilesFromTsConfig: true,\n  });\n\n  // NOTE: We add our override declaration here before loading all files\n  // This sets `__cacheDisabled` on the turbo cache, which disables the cache temporarily\n  // If we don't disable the cache then we couldn't regenerate it from inferred types\n  const overrideFile = project.createSourceFile(\n    '__gql-tada-override__.d.ts',\n    DECLARATION_OVERRIDE,\n    {\n      overwrite: true,\n      scriptKind: ScriptKind.TS,\n    }\n  );\n  if (overrideFile._markAsInProject) overrideFile._markAsInProject();\n\n  project.addSourceFilesFromTsConfig(params.configPath);\n\n  const getVirtualPosition = await loadVirtualCode(projectPath, project, ts);\n  if (!!getVirtualPosition) {\n    yield { kind: 'EXTERNAL_WARNING' };\n  }\n\n  // Filter source files by whether they're under the relevant root path\n  const sourceFiles = project.getSourceFiles().filter((sourceFile) => {\n    const filePath = path.resolve(projectPath, sourceFile.getFilePath());\n    const relative = path.relative(params.rootPath, filePath);\n    return !relative.startsWith('..');\n  });\n\n  yield {\n    kind: 'FILE_COUNT',\n    fileCount: sourceFiles.length,\n  };\n\n  const checker = project.getTypeChecker().compilerObject;\n  for (const { compilerNode: sourceFile } of sourceFiles) {\n    let filePath = sourceFile.fileName;\n    const cache: Record<string, string> = {};\n    const warnings: TurboWarning[] = [];\n\n    const calls = findAllCallExpressions(sourceFile, params.pluginConfig);\n    for (const call of calls) {\n      const returnType = checker.getTypeAtLocation(call);\n      const argumentType = checker.getTypeAtLocation(call.arguments[0]);\n      // NOTE: `returnType.symbol` is incorrectly typed and is in fact\n      // optional and not always present\n      if (!returnType.symbol || returnType.symbol.getEscapedName() !== 'TadaDocumentNode') {\n        const position = getFilePosition(\n          sourceFile,\n          call.getStart(),\n          undefined,\n          getVirtualPosition\n        );\n        filePath = position.file;\n        warnings.push({\n          message:\n            `The discovered document is not of type \"TadaDocumentNode\".\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.file,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      const key: string =\n        'value' in argumentType &&\n        typeof argumentType.value === 'string' &&\n        (argumentType.flags & TypeFlags.StringLiteral) === 0\n          ? JSON.stringify(argumentType.value)\n          : checker.typeToString(argumentType, call, BUILDER_FLAGS);\n      cache[key] = checker.typeToString(returnType, call, BUILDER_FLAGS);\n    }\n\n    yield {\n      kind: 'FILE_TURBO',\n      filePath,\n      cache,\n      warnings,\n    };\n  }\n}\n\nexport const runTurbo = expose(_runTurbo);\n\nconst BUILDER_FLAGS: TypeFormatFlags =\n  TypeFormatFlags.NoTruncation |\n  TypeFormatFlags.NoTypeReduction |\n  TypeFormatFlags.InTypeAlias |\n  TypeFormatFlags.UseFullyQualifiedType |\n  TypeFormatFlags.GenerateNamesForShadowedTypeParams |\n  TypeFormatFlags.UseAliasDefinedOutsideCurrentScope |\n  TypeFormatFlags.AllowUniqueESSymbolType |\n  TypeFormatFlags.WriteTypeArgumentsOfSignature;\n\nconst DECLARATION_OVERRIDE = `\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n`.trim();\n\nfunction findAllCallExpressions(\n  sourceFile: ts.SourceFile,\n  config: GraphQLSPConfig\n): Array<ts.CallExpression> {\n  const result: ts.CallExpression[] = [];\n  const templates = new Set([config.template, 'graphql', 'gql'].filter(Boolean));\n  function find(node: ts.Node) {\n    if (ts.isCallExpression(node) && templates.has(node.expression.getText())) {\n      result.push(node);\n      return;\n    } else {\n      ts.forEachChild(node, find);\n    }\n  }\n  find(sourceFile);\n  return result;\n}\n"],"names":["runTurbo","expose","async","_runTurbo","params","init","typescript","ts","projectPath","path","dirname","configPath","project","Project","tsConfigFilePath","skipAddingFilesFromTsConfig","overrideFile","createSourceFile","DECLARATION_OVERRIDE","overwrite","scriptKind","ScriptKind","TS","_markAsInProject","addSourceFilesFromTsConfig","getVirtualPosition","loadVirtualCode","kind","sourceFiles","getSourceFiles","filter","sourceFile","filePath","resolve","getFilePath","relative","rootPath","startsWith","fileCount","length","checker","getTypeChecker","compilerObject","compilerNode","fileName","cache","warnings","calls","findAllCallExpressions","pluginConfig","call","returnType","getTypeAtLocation","argumentType","arguments","symbol","getEscapedName","position","getFilePosition","getStart","undefined","file","push","message","line","col","value","flags","TypeFlags","StringLiteral","JSON","stringify","typeToString","BUILDER_FLAGS","TypeFormatFlags","NoTruncation","NoTypeReduction","InTypeAlias","UseFullyQualifiedType","GenerateNamesForShadowedTypeParams","UseAliasDefinedOutsideCurrentScope","AllowUniqueESSymbolType","WriteTypeArgumentsOfSignature","trim","config","result","templates","Set","template","Boolean","find","node","isCallExpression","has","expression","getText","forEachChild"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2GaA,IAAWC,EAAMA,QA1F9BC,gBAAgBC,UAAUC;EACxBC,OAAK;IAAEC,YAAYC,EAAAA;;EAEnB,IAAMC,IAAcC,EAAKC,QAAQN,EAAOO;EACxC,IAAMC,IAAU,IAAIC,UAAQ;IAC1BC,kBAAkBV,EAAOO;IACzBI,8BAA6B;;EAM/B,IAAMC,IAAeJ,EAAQK,iBAC3B,8BACAC,GACA;IACEC,YAAW;IACXC,YAAYC,EAAUA,WAACC;;EAG3B,IAAIN,EAAaO;IAAkBP,EAAaO;;EAEhDX,EAAQY,2BAA2BpB,EAAOO;EAE1C,IAAMc,UAA2BC,EAAeA,gBAAClB,GAAaI,GAASL,EAAEA;EACzE,IAAMkB;UACE;MAAEE,MAAM;;;EAIhB,IAAMC,IAAchB,EAAQiB,iBAAiBC,QAAQC;IACnD,IAAMC,IAAWvB,EAAKwB,QAAQzB,GAAauB,EAAWG;IAEtD,QADiBzB,EAAK0B,SAAS/B,EAAOgC,UAAUJ,GAC/BK,WAAW;AAAK;QAG7B;IACJV,MAAM;IACNW,WAAWV,EAAYW;;EAGzB,IAAMC,IAAU5B,EAAQ6B,iBAAiBC;EACzC,KAAK,KAAQC,cAAcZ,MAAgBH,GAAa;IACtD,IAAII,IAAWD,EAAWa;IAC1B,IAAMC,IAAgC,CAAA;IACtC,IAAMC,IAA2B;IAEjC,IAAMC,IAAQC,uBAAuBjB,GAAY3B,EAAO6C;IACxD,KAAK,IAAMC,KAAQH,GAAO;MACxB,IAAMI,IAAaX,EAAQY,kBAAkBF;MAC7C,IAAMG,IAAeb,EAAQY,kBAAkBF,EAAKI,UAAU;MAG9D,KAAKH,EAAWI,UAAiD,uBAAvCJ,EAAWI,OAAOC,kBAAyC;QACnF,IAAMC,IAAWC,EAAeA,gBAC9B3B,GACAmB,EAAKS,iBACLC,GACAnC;QAEFO,IAAWyB,EAASI;QACpBf,EAASgB,KAAK;UACZC,SACG;UAEHF,MAAMJ,EAASI;UACfG,MAAMP,EAASO;UACfC,KAAKR,EAASQ;;QAEhB;AACF;MAQApB,EALE,WAAWQ,KACmB,mBAAvBA,EAAaa,SAC+B,MAAlDb,EAAac,QAAQC,YAAUC,iBAC5BC,KAAKC,UAAUlB,EAAaa,SAC5B1B,EAAQgC,aAAanB,GAAcH,GAAMuB,MAClCjC,EAAQgC,aAAarB,GAAYD,GAAMuB;AACtD;UAEM;MACJ9C,MAAM;MACNK;MACAa;MACAC;;AAEJ;AACF;;AAIA,IAAM2B,IACJC,EAAeA,gBAACC,eAChBD,EAAAA,gBAAgBE,kBAChBF,EAAAA,gBAAgBG,cAChBH,EAAeA,gBAACI,wBAChBJ,EAAeA,gBAACK,qCAChBL,kBAAgBM,qCAChBN,EAAAA,gBAAgBO,0BAChBP,EAAeA,gBAACQ;;AAElB,IAAMhE,IAAwB,gJAO5BiE;;AAEF,SAASnC,uBACPjB,GACAqD;EAEA,IAAMC,IAA8B;EACpC,IAAMC,IAAY,IAAIC,IAAI,EAACH,EAAOI,UAAU,WAAW,QAAO1D,OAAO2D;GACrE,SAASC,KAAKC;IACZ,IAAIpF,EAAEA,GAACqF,iBAAiBD,MAASL,EAAUO,IAAIF,EAAKG,WAAWC,YAAY;MACzEV,EAAOvB,KAAK6B;MACZ;AACF;MACEpF,EAAAA,GAAGyF,aAAaL,GAAMD;;AAE1B,GACAA,CAAK3D;EACL,OAAOsD;AACT;;"}
+{"version":3,"file":"thread-chunk2.js","sources":["../../src/commands/turbo/thread.ts"],"sourcesContent":["import ts from 'typescript';\nimport type { GraphQLSPConfig } from '@gql.tada/internal';\n\nimport { programFactory } from '../../ts';\nimport { expose } from '../../threads';\n\nimport type { TurboSignal, TurboWarning } from './types';\n\nexport interface TurboParams {\n  rootPath: string;\n  configPath: string;\n  pluginConfig: GraphQLSPConfig;\n}\n\nasync function* _runTurbo(params: TurboParams): AsyncIterableIterator<TurboSignal> {\n  const factory = programFactory(params);\n\n  // NOTE: We add our override declaration here before loading all files\n  // This sets `__cacheDisabled` on the turbo cache, which disables the cache temporarily\n  // If we don't disable the cache then we couldn't regenerate it from inferred types\n  factory.addSourceFile({\n    fileId: '__gql-tada-override__.d.ts',\n    sourceText: DECLARATION_OVERRIDE,\n    scriptKind: ts.ScriptKind.TS,\n  });\n\n  const externalFiles = factory.createExternalFiles();\n  if (externalFiles.length) {\n    yield { kind: 'EXTERNAL_WARNING' };\n    await factory.addVirtualFiles(externalFiles);\n  }\n\n  const container = factory.build();\n  const sourceFiles = container.getSourceFiles();\n\n  yield {\n    kind: 'FILE_COUNT',\n    fileCount: sourceFiles.length,\n  };\n\n  const checker = container.program.getTypeChecker();\n  for (const sourceFile of sourceFiles) {\n    let filePath = sourceFile.fileName;\n    const cache: Record<string, string> = {};\n    const warnings: TurboWarning[] = [];\n\n    const calls = findAllCallExpressions(sourceFile, params.pluginConfig);\n    for (const call of calls) {\n      const returnType = checker.getTypeAtLocation(call);\n      const argumentType = checker.getTypeAtLocation(call.arguments[0]);\n      // NOTE: `returnType.symbol` is incorrectly typed and is in fact\n      // optional and not always present\n      if (!returnType.symbol || returnType.symbol.getEscapedName() !== 'TadaDocumentNode') {\n        const position = container.getSourcePosition(sourceFile, call.getStart());\n        filePath = position.fileName;\n        warnings.push({\n          message:\n            `The discovered document is not of type \"TadaDocumentNode\".\\n` +\n            'If this is unexpected, please file an issue describing your case.',\n          file: position.fileName,\n          line: position.line,\n          col: position.col,\n        });\n        continue;\n      }\n\n      const key: string =\n        'value' in argumentType &&\n        typeof argumentType.value === 'string' &&\n        (argumentType.flags & ts.TypeFlags.StringLiteral) === 0\n          ? JSON.stringify(argumentType.value)\n          : checker.typeToString(argumentType, call, BUILDER_FLAGS);\n      cache[key] = checker.typeToString(returnType, call, BUILDER_FLAGS);\n    }\n\n    yield {\n      kind: 'FILE_TURBO',\n      filePath,\n      cache,\n      warnings,\n    };\n  }\n}\n\nexport const runTurbo = expose(_runTurbo);\n\nconst BUILDER_FLAGS: ts.TypeFormatFlags =\n  ts.TypeFormatFlags.NoTruncation |\n  ts.TypeFormatFlags.NoTypeReduction |\n  ts.TypeFormatFlags.InTypeAlias |\n  ts.TypeFormatFlags.UseFullyQualifiedType |\n  ts.TypeFormatFlags.GenerateNamesForShadowedTypeParams |\n  ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope |\n  ts.TypeFormatFlags.AllowUniqueESSymbolType |\n  ts.TypeFormatFlags.WriteTypeArgumentsOfSignature;\n\nconst DECLARATION_OVERRIDE = `\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n`.trim();\n\nfunction findAllCallExpressions(\n  sourceFile: ts.SourceFile,\n  config: GraphQLSPConfig\n): Array<ts.CallExpression> {\n  const result: ts.CallExpression[] = [];\n  const templates = new Set([config.template, 'graphql', 'gql'].filter(Boolean));\n  function find(node: ts.Node) {\n    if (ts.isCallExpression(node) && templates.has(node.expression.getText())) {\n      result.push(node);\n      return;\n    } else {\n      ts.forEachChild(node, find);\n    }\n  }\n  find(sourceFile);\n  return result;\n}\n"],"names":["runTurbo","expose","async","_runTurbo","params","factory","programFactory","addSourceFile","fileId","sourceText","DECLARATION_OVERRIDE","scriptKind","ts","ScriptKind","TS","externalFiles","createExternalFiles","length","kind","addVirtualFiles","container","build","sourceFiles","getSourceFiles","fileCount","checker","program","getTypeChecker","sourceFile","filePath","fileName","cache","warnings","calls","findAllCallExpressions","pluginConfig","call","returnType","getTypeAtLocation","argumentType","arguments","symbol","getEscapedName","position","getSourcePosition","getStart","push","message","file","line","col","value","flags","TypeFlags","StringLiteral","JSON","stringify","typeToString","BUILDER_FLAGS","TypeFormatFlags","NoTruncation","NoTypeReduction","InTypeAlias","UseFullyQualifiedType","GenerateNamesForShadowedTypeParams","UseAliasDefinedOutsideCurrentScope","AllowUniqueESSymbolType","WriteTypeArgumentsOfSignature","trim","config","result","templates","Set","template","filter","Boolean","find","node","isCallExpression","has","expression","getText","forEachChild"],"mappings":";;;;IAoFaA,IAAWC,EAAMA,QAtE9BC,gBAAgBC,UAAUC;EACxB,IAAMC,IAAUC,iBAAeF;EAK/BC,EAAQE,cAAc;IACpBC,QAAQ;IACRC,YAAYC;IACZC,YAAYC,EAAGC,WAAWC;;EAG5B,IAAMC,IAAgBV,EAAQW;EAC9B,IAAID,EAAcE,QAAQ;UAClB;MAAEC,MAAM;;UACRb,EAAQc,gBAAgBJ;AAChC;EAEA,IAAMK,IAAYf,EAAQgB;EAC1B,IAAMC,IAAcF,EAAUG;QAExB;IACJL,MAAM;IACNM,WAAWF,EAAYL;;EAGzB,IAAMQ,IAAUL,EAAUM,QAAQC;EAClC,KAAK,IAAMC,KAAcN,GAAa;IACpC,IAAIO,IAAWD,EAAWE;IAC1B,IAAMC,IAAgC,CAAA;IACtC,IAAMC,IAA2B;IAEjC,IAAMC,IAAQC,uBAAuBN,GAAYxB,EAAO+B;IACxD,KAAK,IAAMC,KAAQH,GAAO;MACxB,IAAMI,IAAaZ,EAAQa,kBAAkBF;MAC7C,IAAMG,IAAed,EAAQa,kBAAkBF,EAAKI,UAAU;MAG9D,KAAKH,EAAWI,UAAiD,uBAAvCJ,EAAWI,OAAOC,kBAAyC;QACnF,IAAMC,IAAWvB,EAAUwB,kBAAkBhB,GAAYQ,EAAKS;QAC9DhB,IAAWc,EAASb;QACpBE,EAASc,KAAK;UACZC,SACG;UAEHC,MAAML,EAASb;UACfmB,MAAMN,EAASM;UACfC,KAAKP,EAASO;;QAEhB;AACF;MAQAnB,EALE,WAAWQ,KACmB,mBAAvBA,EAAaY,SACkC,MAArDZ,EAAaa,QAAQxC,EAAGyC,UAAUC,iBAC/BC,KAAKC,UAAUjB,EAAaY,SAC5B1B,EAAQgC,aAAalB,GAAcH,GAAMsB,MAClCjC,EAAQgC,aAAapB,GAAYD,GAAMsB;AACtD;UAEM;MACJxC,MAAM;MACNW;MACAE;MACAC;;AAEJ;AACF;;AAIA,IAAM0B,IACJ9C,EAAG+C,gBAAgBC,eACnBhD,EAAG+C,gBAAgBE,kBACnBjD,EAAG+C,gBAAgBG,cACnBlD,EAAG+C,gBAAgBI,wBACnBnD,EAAG+C,gBAAgBK,qCACnBpD,EAAG+C,gBAAgBM,qCACnBrD,EAAG+C,gBAAgBO,0BACnBtD,EAAG+C,gBAAgBQ;;AAErB,IAAMzD,IAAwB,gJAO5B0D;;AAEF,SAASlC,uBACPN,GACAyC;EAEA,IAAMC,IAA8B;EACpC,IAAMC,IAAY,IAAIC,IAAI,EAACH,EAAOI,UAAU,WAAW,QAAOC,OAAOC;GACrE,SAASC,KAAKC;IACZ,IAAIjE,EAAGkE,iBAAiBD,MAASN,EAAUQ,IAAIF,EAAKG,WAAWC,YAAY;MACzEX,EAAOxB,KAAK+B;MACZ;AACF;MACEjE,EAAGsE,aAAaL,GAAMD;;AAE1B,GACAA,CAAKhD;EACL,OAAO0C;AACT;;"}