@gql.tada/cli-utils 1.7.3 → 1.8.0

package/dist/chunks/thread-chunk2.mjs

@@ -1,212 +1,614 @@
 import e from "typescript";
 
-import * as r from "node:path";
+import r from "node:v8";
 
-import { getSchemaNamesFromConfig as a } from "@gql.tada/internal";
+import t from "node:vm";
 
-import { findAllCallExpressions as t } from "@0no-co/graphqlsp/api";
+import * as a from "node:fs";
 
-import { e as i } from "./index-chunk2.mjs";
+import * as i from "node:path";
 
-import { p as o } from "./index-chunk.mjs";
+import * as n from "node:crypto";
 
-function traceCallToImportSource(r, a, t) {
-  var i = t.getTypeChecker();
-  var o = r.expression;
-  var s;
-  if (e.isIdentifier(o)) {
-    s = o;
-  } else if (e.isPropertyAccessExpression(o) && e.isIdentifier(o.expression)) {
-    s = o.expression;
+import { getSchemaNamesFromConfig as o, getSchemaConfigForName as s } from "@gql.tada/internal";
+
+import { findAllCallExpressions as u } from "@0no-co/graphqlsp/api";
+
+import { e as l } from "./index-chunk2.mjs";
+
+import { p as c } from "./index-chunk.mjs";
+
+var f = /@gql\.tada\/hash\s+([^\s*]+)/;
+
+function getHashComment(r, t) {
+  var a = e.getLeadingCommentRanges(r, t.pos) || [];
+  for (var i = a.length - 1; i >= 0; i--) {
+    var n = r.slice(a[i].pos, a[i].end);
+    var o = f.exec(n);
+    if (o) {
+      return o[1];
+    }
   }
-  if (!s) {
-    return;
+  return;
+}
+
+var p = "turbo-document-hash-v1";
+
+function createDocumentHasher(r) {
+  var t = new WeakMap;
+  var a = new Map;
+  var i = new WeakSet;
+  var hashCallExpression = (e, r) => {
+    var a = r || "";
+    var n = t.get(e)?.get(a);
+    if (n) {
+      return n;
+    } else if (i.has(e)) {
+      return {
+        hashable: !1
+      };
+    }
+    i.add(e);
+    var o = computeCallExpressionHash(e, r);
+    i.delete(e);
+    var s = t.get(e);
+    if (!s) {
+      s = new Map;
+      t.set(e, s);
+    }
+    s.set(a, o);
+    return o;
+  };
+  var computeCallExpressionHash = (t, a) => {
+    var i = function getStaticStringValue(r) {
+      if (!r) {
+        return;
+      }
+      r = unwrapExpression(r);
+      if (e.isStringLiteral(r) || e.isNoSubstitutionTemplateLiteral(r)) {
+        return r.text;
+      }
+      return;
+    }(t.arguments[0]);
+    if (null == i) {
+      return {
+        hashable: !1
+      };
+    }
+    var o = getFragmentHashes(t.arguments[1], a);
+    if (!o) {
+      return {
+        hashable: !1
+      };
+    }
+    var s = n.createHash("sha256");
+    addHashPart(s, p);
+    addHashPart(s, a || "");
+    addHashPart(s, r.schemaFingerprints.get(a) || "");
+    addHashPart(s, i);
+    for (var u of o) {
+      addHashPart(s, u);
+    }
+    return {
+      hashable: !0,
+      documentHash: `sha256:${s.digest("hex").slice(0, 32)}`
+    };
+  };
+  var getFragmentHashes = (r, t) => {
+    if (!r) {
+      return [];
+    }
+    r = unwrapExpression(r);
+    if (e.isArrayLiteralExpression(r)) {
+      var a = [];
+      for (var i of r.elements) {
+        if (e.isSpreadElement(i)) {
+          var n = getFragmentHashes(i.expression, t);
+          if (!n) {
+            return null;
+          }
+          a.push(...n);
+          continue;
+        }
+        var o = resolveDocumentCallExpression(i);
+        if (!o) {
+          return null;
+        }
+        var s = hashCallExpression(o, t);
+        if (!s.hashable || !s.documentHash) {
+          return null;
+        }
+        a.push(s.documentHash);
+      }
+      return a;
+    }
+    var u = resolveDeclarationInitializer(r);
+    if (u && u !== r) {
+      return getFragmentHashes(u, t);
+    }
+    return null;
+  };
+  var resolveDocumentCallExpression = r => {
+    r = unwrapExpression(r);
+    if (e.isCallExpression(r)) {
+      return r;
+    }
+    var t = getSymbol(r);
+    if (!t) {
+      return null;
+    }
+    var i = a.get(t);
+    if (void 0 !== i) {
+      return i;
+    }
+    var n = resolveSymbolCallExpression(t);
+    a.set(t, n);
+    return n;
+  };
+  var resolveDeclarationInitializer = r => {
+    var t = getSymbol(r);
+    if (!t) {
+      return null;
+    }
+    for (var a of t.declarations || []) {
+      if (e.isVariableDeclaration(a) && a.initializer) {
+        return a.initializer;
+      }
+    }
+    return null;
+  };
+  var resolveSymbolCallExpression = r => {
+    for (var t of r.declarations || []) {
+      if (e.isVariableDeclaration(t) && t.initializer) {
+        var a = unwrapExpression(t.initializer);
+        if (e.isCallExpression(a)) {
+          return a;
+        }
+      }
+    }
+    return null;
+  };
+  var getSymbol = t => {
+    var a = r.checker.getSymbolAtLocation(t);
+    if (a && a.flags & e.SymbolFlags.Alias) {
+      a = r.checker.getAliasedSymbol(a);
+    }
+    return a;
+  };
+  return {
+    hashCallExpression
+  };
+}
+
+function unwrapExpression(r) {
+  while (e.isParenthesizedExpression(r) || e.isAsExpression(r) || e.isTypeAssertionExpression(r) || e.isSatisfiesExpression(r) || e.isNonNullExpression(r)) {
+    r = r.expression;
+  }
+  return r;
+}
+
+function addHashPart(e, r) {
+  e.update(`${r.length}:`);
+  e.update(r);
+  e.update("\0");
+}
+
+var d = /(?:^|[^\w])(query|mutation|subscription|fragment)\b/;
+
+function hasGraphQLDocumentCandidate(r) {
+  if (!r.text.includes("{")) {
+    return !1;
+  }
+  var t = !1;
+  var visit = r => {
+    if (t) {
+      return;
+    }
+    if (e.isCallExpression(r)) {
+      var a = r.arguments[0];
+      if (a && e.isStringLiteralLike(a)) {
+        var i = a.text;
+        if (i.includes("{") && function isGraphQLDocumentCandidateText(e) {
+          if (d.test(e)) {
+            return !0;
+          }
+          for (var r of e.split("\n")) {
+            var t = r.trimStart();
+            if (!t || t.startsWith("#")) {
+              continue;
+            }
+            return t.startsWith("{");
+          }
+          return !1;
+        }(i)) {
+          t = !0;
+          return;
+        }
+      }
+    }
+    e.forEachChild(r, visit);
+  };
+  visit(r);
+  return t;
+}
+
+var m = 262144e4;
+
+function traceCallToImportSource(r, t, a, i) {
+  var n = r.expression;
+  var o;
+  if (e.isIdentifier(n)) {
+    o = n;
+  } else if (e.isPropertyAccessExpression(n) && e.isIdentifier(n.expression)) {
+    o = n.expression;
   }
-  var n = i.getSymbolAtLocation(s);
-  if (!n || !n.declarations) {
+  if (!o) {
     return;
   }
-  for (var l of n.declarations) {
-    var u = findImportDeclaration(l);
-    if (u && e.isStringLiteral(u.moduleSpecifier)) {
-      return resolveModulePath(u.moduleSpecifier.text, a, t);
+  var s = `${t.fileName}\0${o.text}`;
+  if (i.traces.has(s)) {
+    return i.traces.get(s);
+  }
+  var u;
+  var l = a.getTypeChecker().getSymbolAtLocation(o);
+  if (l && l.declarations) {
+    for (var c of l.declarations) {
+      var f = findImportDeclaration(c);
+      if (f && e.isStringLiteral(f.moduleSpecifier)) {
+        u = resolveModulePath(f.moduleSpecifier.text, t, a, i);
+        break;
+      }
     }
   }
-  return;
+  i.traces.set(s, u);
+  return u;
 }
 
 function findImportDeclaration(r) {
-  var a = r;
-  while (a) {
-    if (e.isImportDeclaration(a)) {
-      return a;
+  var t = r;
+  while (t) {
+    if (e.isImportDeclaration(t)) {
+      return t;
     }
-    a = a.parent;
+    t = t.parent;
   }
   return;
 }
 
-function resolveModulePath(r, a, t) {
-  var i = t.getCompilerOptions();
-  var o = e.createCompilerHost(i);
-  var s = e.resolveModuleName(r, a.fileName, i, o);
-  if (s.resolvedModule) {
-    return s.resolvedModule.resolvedFileName;
+function resolveModulePath(r, t, a, i) {
+  var n = a.getCompilerOptions();
+  var o = i.host || (i.host = e.createCompilerHost(n));
+  var s = i.resolutionCache || (i.resolutionCache = e.createModuleResolutionCache(o.getCurrentDirectory(), o.getCanonicalFileName.bind(o), n));
+  var u = e.resolveModuleName(r, t.fileName, n, o, s);
+  if (u.resolvedModule) {
+    return u.resolvedModule.resolvedFileName;
   }
   return;
 }
 
-function collectImportsFromSourceFile(a, t, i, o, s) {
-  var n = [];
-  var l = function getTadaOutputPaths(e) {
-    var r = [];
+function collectImportsFromSourceFile(r, t, a, n, o, s, u) {
+  var l = [];
+  var c = function getTadaOutputPaths(e, r) {
+    var t = [];
     if ("schema" in e && e.tadaOutputLocation) {
-      r.push(e.tadaOutputLocation);
-    }
-    return r;
-  }(t);
-  !function visit(t) {
-    if (e.isImportDeclaration(t) && e.isStringLiteral(t.moduleSpecifier)) {
-      var u = t.moduleSpecifier.text;
-      if (!function isTadaImport(e, a, t) {
-        if (e.startsWith(".")) {
-          var i = r.dirname(a);
-          var o = r.resolve(i, e);
-          return t.some((e => {
-            var a = r.resolve(e);
-            return o === a || o.startsWith(a + r.sep);
-          }));
+      t.push(i.resolve(r, e.tadaOutputLocation));
+    } else if ("schemas" in e) {
+      for (var a of e.schemas) {
+        if (a.tadaOutputLocation) {
+          t.push(i.resolve(r, a.tadaOutputLocation));
         }
-        return t.some((r => e === r || e.startsWith(r + "/")));
-      }(u, a.fileName, l)) {
-        var c = t.getFullText().trim();
-        if (o) {
-          var p = i(u, a.fileName, o);
-          if (s) {
-            if (p.endsWith(".ts") || p.endsWith(".tsx")) {
-              p = p.replace(/\.ts$/, ".js").replace(/\.tsx$/, ".js");
+      }
+    }
+    return t;
+  }(t, o);
+  for (var f of r.statements) {
+    if (e.isImportDeclaration(f) && e.isStringLiteral(f.moduleSpecifier)) {
+      var p = f.moduleSpecifier.text;
+      if (!isTadaImport(p, r.fileName, c, n)) {
+        var d = f.getFullText().trim();
+        if (s) {
+          var m = a(p, r.fileName, s);
+          if (u) {
+            if (m.endsWith(".ts") || m.endsWith(".tsx")) {
+              m = m.replace(/\.ts$/, ".js").replace(/\.tsx$/, ".js");
             }
           } else {
-            p = p.replace(/\.ts$/, "").replace(/\.tsx$/, "");
+            m = m.replace(/\.ts$/, "").replace(/\.tsx$/, "");
           }
-          if (p && !p.includes("gql.tada")) {
-            n.push({
-              specifier: p,
-              importClause: c.replace(u, p)
+          if (m && !m.includes("gql.tada")) {
+            l.push({
+              specifier: m,
+              importClause: d.replace(p, m)
             });
           }
         } else {
-          n.push({
-            specifier: u,
-            importClause: c
+          l.push({
+            specifier: p,
+            importClause: d
           });
         }
       }
     }
-    e.forEachChild(t, visit);
-  }(a);
-  return n;
+  }
+  return l;
+}
+
+function isTadaImport(e, r, t, a) {
+  var n = a(e, r);
+  if (n) {
+    return t.some((e => n === e));
+  }
+  if (e.startsWith(".")) {
+    var o = i.dirname(r);
+    var s = i.resolve(o, e);
+    return t.some((e => s === e));
+  }
+  return t.some((r => e === r || e.startsWith(r + "/")));
 }
 
-var s = i((async function* _runTurbo(r) {
-  var i = a(r.pluginConfig);
-  var s = o(r);
-  s.addSourceFile({
+async function* _runTurbo(r) {
+  var t = o(r.pluginConfig);
+  var n = c(r);
+  var s = new Map;
+  var getCachedDocuments = t => {
+    var i = getTurboOutputPath(r.turboOutputPath, t);
+    if (!i) {
+      return new Map;
+    }
+    var n = s.get(i);
+    if (!n) {
+      n = function readCachedTurboDocuments(r) {
+        var t = new Map;
+        if (!r || !a.existsSync(r)) {
+          return t;
+        }
+        var i;
+        try {
+          i = a.readFileSync(r, "utf8");
+        } catch {
+          return t;
+        }
+        var n = e.createSourceFile(r, i, e.ScriptTarget.Latest, !0, e.ScriptKind.TS);
+        var visit = r => {
+          if (e.isInterfaceDeclaration(r) && "setupCache" === r.name.text) {
+            for (var a of r.members) {
+              if (!e.isPropertySignature(a) || !a.type) {
+                continue;
+              }
+              if (!e.isStringLiteral(a.name) && !e.isNumericLiteral(a.name)) {
+                continue;
+              }
+              var o = getHashComment(i, a);
+              if (!o) {
+                continue;
+              }
+              t.set(JSON.stringify(a.name.text), {
+                documentHash: o,
+                documentType: a.type.getText(n)
+              });
+            }
+          }
+          e.forEachChild(r, visit);
+        };
+        visit(n);
+        return t;
+      }(i);
+      s.set(i, n);
+    }
+    return n;
+  };
+  n.addSourceFile({
     fileId: "__gql-tada-override__.d.ts",
-    sourceText: l,
+    sourceText: y,
     scriptKind: e.ScriptKind.TS
   });
-  var u = s.createExternalFiles();
-  if (u.length) {
+  var l = n.createExternalFiles();
+  if (l.length) {
     yield {
       kind: "EXTERNAL_WARNING"
     };
-    await s.addVirtualFiles(u);
+    await n.addVirtualFiles(l);
   }
-  var c = s.build();
-  var p = c.buildPluginInfo(r.pluginConfig);
-  var m = c.getSourceFiles();
+  var f = n.build();
+  var p = f.buildPluginInfo(r.pluginConfig);
+  var d = new Set(function getTurboOutputPaths(e) {
+    return "string" == typeof e ? [ e ] : e.map((e => e.path));
+  }(r.turboOutputPath).map((e => i.resolve(e))));
+  var h = n.rootFileNames.filter((e => function shouldScanTurboFile(e, r) {
+    if (r.has(i.resolve(e))) {
+      return !1;
+    }
+    if (e.endsWith(".d.ts") || e.endsWith(".d.mts") || e.endsWith(".d.cts")) {
+      return !1;
+    }
+    return !/(^|[/\\])node_modules([/\\]|$)/.test(e);
+  }(e, d)));
   yield {
     kind: "FILE_COUNT",
-    fileCount: m.length
+    fileCount: h.length
   };
-  var d = c.program.getTypeChecker();
-  var f = new Map;
-  for (var v of m) {
-    var g = v.fileName;
-    var h = [];
-    var y = [];
-    var T = t(v, p, !1).nodes;
-    var _loop = async function*(a) {
-      var t = a.node.parent;
-      if (!e.isCallExpression(t)) {
-        return 0;
+  var v = new Map;
+  var S = {
+    traces: new Map,
+    host: void 0,
+    resolutionCache: void 0
+  };
+  var processSourceFile = (a, i, o, s) => {
+    var l = a.fileName;
+    var c = [];
+    var f = [];
+    if (!hasGraphQLDocumentCandidate(a)) {
+      return {
+        filePath: l,
+        documents: c,
+        warnings: f
+      };
+    }
+    var p = u(a, o, {
+      searchExternal: !1,
+      collectFragments: !1
+    }).nodes;
+    for (var d of p) {
+      var m = d.node.parent;
+      if (!e.isCallExpression(m)) {
+        continue;
       }
-      var o = c.getSourcePosition(v, t.getStart());
-      g = o.fileName;
-      if (!i.has(a.schema)) {
-        y.push({
-          message: a.schema ? `The '${a.schema}' schema is not in the configuration but was referenced by document.` : i.size > 1 ? "The document is not for a known schema. Have you re-generated the output file?" : "Multiple schemas are configured, but the document is not for a specific schema.",
-          file: o.fileName,
-          line: o.line,
-          col: o.col
+      var h = i.getSourcePosition(a, m.getStart());
+      l = h.fileName;
+      if (!t.has(d.schema)) {
+        f.push({
+          message: d.schema ? `The '${d.schema}' schema is not in the configuration but was referenced by document.` : t.size > 1 ? "The document is not for a known schema. Have you re-generated the output file?" : "Multiple schemas are configured, but the document is not for a specific schema.",
+          file: h.fileName,
+          line: h.line,
+          col: h.col
         });
-        return 0;
+        continue;
       }
-      var l = traceCallToImportSource(t, v, c.program);
-      if (l && !f.has(l)) {
-        var u = c.program.getSourceFile(l);
-        if (u) {
-          var p = Array.isArray(r.turboOutputPath) ? r.turboOutputPath.find((e => e.schemaName === a.schema))?.path : r.turboOutputPath;
-          var m = collectImportsFromSourceFile(u, r.pluginConfig, s.resolveModuleName.bind(s), p, !!s.wasOriginallyNodeNext);
-          f.set(l, {
-            absolutePath: l,
-            imports: m
+      var y = traceCallToImportSource(m, a, i.program, S);
+      if (y && !v.has(y)) {
+        var T = i.program.getSourceFile(y);
+        if (T) {
+          var F = getTurboOutputPath(r.turboOutputPath, d.schema);
+          var b = collectImportsFromSourceFile(T, r.pluginConfig, n.resolveModuleName.bind(n), n.resolveModulePath.bind(n), r.rootPath, F, !!n.wasOriginallyNodeNext);
+          v.set(y, {
+            absolutePath: y,
+            imports: b
           });
         }
       }
-      var T = d.getTypeAtLocation(t);
-      var F = d.getTypeAtLocation(a.node);
-      if (!T.symbol || "TadaDocumentNode" !== T.symbol.getEscapedName()) {
-        y.push({
-          message: 'The discovered document is not of type "TadaDocumentNode".\nIf this is unexpected, please file an issue describing your case.',
-          file: o.fileName,
-          line: o.line,
-          col: o.col
-        });
-        return 0;
+      var C = JSON.stringify(d.node.text);
+      var N = x.hashCallExpression(m, d.schema);
+      var P = N.hashable && N.documentHash ? getCachedDocuments(d.schema).get(C) : void 0;
+      var w = void 0;
+      var E = !1;
+      if (P && P.documentHash === N.documentHash) {
+        w = P.documentType;
+        E = !0;
+      } else {
+        var L = s.getTypeAtLocation(m);
+        if (!L.symbol || "TadaDocumentNode" !== L.symbol.getEscapedName()) {
+          f.push({
+            message: 'The discovered document is not of type "TadaDocumentNode".\nIf this is unexpected, please file an issue describing your case.',
+            file: h.fileName,
+            line: h.line,
+            col: h.col
+          });
+          continue;
+        }
+        w = s.typeToString(L, m, g);
       }
-      var S = "value" in F && "string" == typeof F.value && !(F.flags & e.TypeFlags.StringLiteral) ? JSON.stringify(F.value) : d.typeToString(F, t, n);
-      var N = d.typeToString(T, t, n);
-      h.push({
-        schemaName: a.schema,
-        argumentKey: S,
-        documentType: N
+      c.push({
+        schemaName: d.schema,
+        argumentKey: C,
+        documentType: w,
+        documentHash: N.documentHash,
+        isCached: E
       });
+    }
+    return {
+      filePath: l,
+      documents: c,
+      warnings: f
     };
-    for (var F of T) {
-      if (0 === (yield* _loop(F))) {
-        continue;
-      }
+  };
+  var isHeapOverSoftLimit = () => {
+    if (process.memoryUsage().heapUsed < m) {
+      return !1;
     }
+    forceGc();
+    return process.memoryUsage().heapUsed >= m;
+  };
+  var T = f.program.getTypeChecker();
+  var x = createDocumentHasher({
+    get checker() {
+      return T;
+    },
+    schemaFingerprints: computeSchemaFingerprints(r)
+  });
+  var F = 0;
+  for (var b of h) {
+    if (F > 0 && (F >= 1e3 || isHeapOverSoftLimit())) {
+      p = (f = n.build()).buildPluginInfo(r.pluginConfig);
+      forceGc();
+      T = f.program.getTypeChecker();
+      F = 0;
+    }
+    var C = f.getSourceFile(b);
+    if (!C) {
+      continue;
+    }
+    var {filePath: N, documents: P, warnings: w} = processSourceFile(C, f, p, T);
+    F++;
     yield {
       kind: "FILE_TURBO",
-      filePath: g,
-      documents: h,
-      warnings: y
+      filePath: N,
+      documents: P,
+      warnings: w
     };
   }
-  if (f.size > 0) {
+  if (v.size > 0) {
     yield {
       kind: "GRAPHQL_SOURCES",
-      sources: Array.from(f.values())
+      sources: Array.from(v.values())
     };
   }
-}));
+}
+
+function computeSchemaFingerprints(e) {
+  var r = new Map;
+  var t = i.dirname(e.configPath);
+  for (var u of o(e.pluginConfig)) {
+    var l = s(e.pluginConfig, u || void 0);
+    var c = l && l.tadaOutputLocation;
+    if (!c) {
+      continue;
+    }
+    var f = void 0;
+    try {
+      f = a.readFileSync(i.resolve(t, c), "utf8");
+    } catch {
+      continue;
+    }
+    var p = n.createHash("sha256").update(f).digest("hex");
+    r.set(u, `sha256:${p.slice(0, 32)}`);
+  }
+  return r;
+}
+
+function getTurboOutputPath(e, r) {
+  if ("string" == typeof e) {
+    return e;
+  }
+  return e.find((e => e.schemaName === r))?.path;
+}
+
+var h;
+
+function forceGc() {
+  if (void 0 === h) {
+    var e = globalThis.gc;
+    if ("function" == typeof e) {
+      h = e;
+    } else {
+      try {
+        r.setFlagsFromString("--expose-gc");
+        h = t.runInNewContext("gc");
+        r.setFlagsFromString("--no-expose-gc");
+      } catch {
+        h = null;
+      }
+    }
+  }
+  if (h) {
+    h();
+  }
+}
+
+var v = l(_runTurbo);
 
-var n = 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 g = 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 y = "\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n".trim();
 
-export { s as runTurbo };
+export { _runTurbo, collectImportsFromSourceFile, v as runTurbo };
 //# sourceMappingURL=thread-chunk2.mjs.map