@emeryld/rrroutes-export 1.0.8 → 1.0.10

package/dist/index.mjs

@@ -1340,9 +1340,11 @@ async function runExportFinalizedLeavesCli(argv) {
 import fs2 from "fs/promises";
 import os from "os";
 import path4 from "path";
+import crypto from "crypto";
 import { execFile as execFileCallback, spawn as spawn2 } from "child_process";
 import { promisify } from "util";
 import { pathToFileURL as pathToFileURL2 } from "url";
+import ts2 from "typescript";
 var execFile = promisify(execFileCallback);
 var CHANGESET_CFG_FIELDS = [
   "summary",
@@ -1355,6 +1357,7 @@ var CHANGESET_CFG_FIELDS = [
   "feed"
 ];
 var SCHEMA_SECTIONS = ["params", "query", "body", "output"];
+var MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"];
 var SOURCE_KEY_BY_SECTION = {
   params: "paramsSchema",
   query: "querySchema",
@@ -1469,6 +1472,65 @@ async function resolveCommitPath(cwd, fromCommit, toCommit) {
   const commits = pathRaw.split("\n").map((item) => item.trim()).filter(Boolean);
   return [fromCommit, ...commits];
 }
+function modulePathStem(modulePath) {
+  const normalized = normalizePath(modulePath).replace(/^\/+/, "");
+  for (const ext of MODULE_EXTENSIONS) {
+    if (normalized.endsWith(ext)) {
+      return normalized.slice(0, -ext.length);
+    }
+  }
+  return normalized;
+}
+function extensionVariants(pathLike) {
+  const stem = modulePathStem(pathLike);
+  return MODULE_EXTENSIONS.map((ext) => `${stem}${ext}`);
+}
+async function buildModulePathCandidates(repoRoot, toCommit, requestedModuleRel) {
+  const requested = normalizePath(requestedModuleRel).replace(/^\/+/, "");
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushCandidate = (value) => {
+    const normalized = normalizePath(value).replace(/^\/+/, "");
+    if (!normalized) return;
+    if (seen.has(normalized)) return;
+    seen.add(normalized);
+    out.push(normalized);
+  };
+  pushCandidate(requested);
+  extensionVariants(requested).forEach(pushCandidate);
+  const history = await runGit(repoRoot, [
+    "log",
+    "--follow",
+    "--name-only",
+    "--format=",
+    toCommit,
+    "--",
+    requested
+  ]);
+  history.split("\n").map((item) => item.trim()).filter(Boolean).forEach((candidate) => {
+    pushCandidate(candidate);
+    extensionVariants(candidate).forEach(pushCandidate);
+  });
+  return out;
+}
+async function commitHasPath(repoRoot, commitSha, candidatePath) {
+  try {
+    await execFile("git", ["cat-file", "-e", `${commitSha}:${candidatePath}`], {
+      cwd: repoRoot
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveModulePathForCommit(repoRoot, commitSha, candidates) {
+  for (const candidate of candidates) {
+    if (await commitHasPath(repoRoot, commitSha, candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
 function parentDirectories(relativePath) {
   const clean = normalizePath(relativePath).replace(/^\/+/, "");
   const dir = path4.posix.dirname(clean);
@@ -1480,8 +1542,11 @@ function parentDirectories(relativePath) {
   }
   return out;
 }
-function buildRelevantConfigFiles(moduleRel, tsconfigRel) {
-  const dirs = new Set(parentDirectories(moduleRel));
+function buildRelevantConfigFiles(moduleCandidates, tsconfigRel) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const moduleRel of moduleCandidates) {
+    parentDirectories(moduleRel).forEach((item) => dirs.add(item));
+  }
   if (tsconfigRel) {
     parentDirectories(tsconfigRel).forEach((item) => dirs.add(item));
     dirs.add(path4.posix.dirname(normalizePath(tsconfigRel)));
@@ -1494,7 +1559,7 @@ function buildRelevantConfigFiles(moduleRel, tsconfigRel) {
   }
   return files;
 }
-async function commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel) {
+async function commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfigRel) {
   const changed = await runGit(cwd, [
     "show",
     "--pretty=format:",
@@ -1503,27 +1568,35 @@ async function commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel) {
     commit
   ]);
   const changedFiles = changed.split("\n").map((item) => normalizePath(item.trim()).replace(/^\/+/, "")).filter(Boolean);
-  const moduleFile = normalizePath(moduleRel).replace(/^\/+/, "");
-  const moduleDir = normalizePath(path4.posix.dirname(moduleFile)).replace(/^\/+/, "");
+  const moduleFiles = Array.from(
+    new Set(moduleCandidates.map((item) => normalizePath(item).replace(/^\/+/, "")))
+  );
+  const moduleDirs = Array.from(
+    new Set(
+      moduleFiles.map((item) => normalizePath(path4.posix.dirname(item)).replace(/^\/+/, "")).filter((item) => item && item !== ".")
+    )
+  );
   const tsconfigFile = tsconfigRel ? normalizePath(tsconfigRel).replace(/^\/+/, "") : void 0;
-  const configFiles = buildRelevantConfigFiles(moduleFile, tsconfigFile);
+  const configFiles = buildRelevantConfigFiles(moduleFiles, tsconfigFile);
   return changedFiles.some((file) => {
-    if (file === moduleFile) return true;
-    if (moduleDir && moduleDir !== "." && (file === moduleDir || file.startsWith(`${moduleDir}/`))) {
-      return true;
+    if (moduleFiles.includes(file)) return true;
+    for (const moduleDir of moduleDirs) {
+      if (file === moduleDir || file.startsWith(`${moduleDir}/`)) {
+        return true;
+      }
     }
     if (tsconfigFile && file === tsconfigFile) return true;
     return configFiles.has(file);
   });
 }
-async function filterCommits(cwd, commits, moduleRel, tsconfigRel) {
+async function filterCommits(cwd, commits, moduleCandidates, tsconfigRel) {
   if (commits.length <= 1) {
     return commits;
   }
   const keep = [commits[0]];
   for (let i = 1; i < commits.length; i += 1) {
     const commit = commits[i];
-    if (await commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel)) {
+    if (await commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfigRel)) {
       keep.push(commit);
     }
   }
@@ -1825,96 +1898,232 @@ async function pathExists(filePath) {
     return false;
   }
 }
-async function createMissingJsImportShims(worktreeDir) {
-  const shimWrites = [];
-  const filesToScan = [];
-  const skipNames = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build"]);
+function isTypeScriptModule(modulePath) {
+  const ext = path4.extname(modulePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts";
+}
+function isJavaScriptModule(modulePath) {
+  const ext = path4.extname(modulePath).toLowerCase();
+  return ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
+async function resolveSnapshotTsconfig(worktreeDir, modulePath, tsconfigOverride) {
+  if (tsconfigOverride) {
+    const resolved = path4.resolve(worktreeDir, tsconfigOverride);
+    if (!await pathExists(resolved)) {
+      throw new Error(`tsconfig not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  let current = path4.dirname(modulePath);
+  const normalizedRoot = normalizePath(path4.resolve(worktreeDir));
+  while (true) {
+    const candidate = path4.join(current, "tsconfig.json");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    if (!normalizePath(parent).startsWith(normalizedRoot)) break;
+    current = parent;
+  }
+  throw new Error(
+    `Unable to resolve tsconfig for TypeScript module: ${modulePath}. Pass --tsconfig to override.`
+  );
+}
+function toEmittedModulePath(moduleRel) {
+  const normalized = normalizePath(moduleRel);
+  if (normalized.endsWith(".mts")) return normalized.slice(0, -4) + ".mjs";
+  if (normalized.endsWith(".cts")) return normalized.slice(0, -4) + ".cjs";
+  if (normalized.endsWith(".tsx")) return normalized.slice(0, -4) + ".js";
+  if (normalized.endsWith(".ts")) return normalized.slice(0, -3) + ".js";
+  return normalized;
+}
+function buildCompileCacheKey(commitSha, moduleRel, tsconfigPath, tsconfigStat) {
+  return crypto.createHash("sha1").update(commitSha).update("\n").update(normalizePath(moduleRel)).update("\n").update(normalizePath(tsconfigPath)).update("\n").update(String(tsconfigStat.mtimeMs)).update("\n").update(String(tsconfigStat.size)).digest("hex");
+}
+async function collectFilesRecursive(rootDir) {
+  const files = [];
   const walk = async (dir) => {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
+      const target = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (skipNames.has(entry.name)) continue;
-        await walk(path4.join(dir, entry.name));
+        await walk(target);
         continue;
       }
-      if (!entry.isFile()) continue;
-      if (!/\\.(ts|tsx|mts)$/.test(entry.name)) continue;
-      filesToScan.push(path4.join(dir, entry.name));
-    }
-  };
-  await walk(worktreeDir);
-  const importRegexes = [
-    /\\bfrom\\s+['\"](\\.[^'\"]+\\.js)['\"]/g,
-    /\\bimport\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g,
-    /\\brequire\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  for (const filePath of filesToScan) {
-    const content = await fs2.readFile(filePath, "utf8");
-    for (const regex of importRegexes) {
-      regex.lastIndex = 0;
-      let match = regex.exec(content);
-      while (match) {
-        const specifier = match[1];
-        const resolvedJs = path4.resolve(path4.dirname(filePath), specifier);
-        if (seen.has(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        seen.add(resolvedJs);
-        if (await pathExists(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        const tsCandidates = [
-          resolvedJs.replace(/\\.js$/, ".ts"),
-          resolvedJs.replace(/\\.js$/, ".mts"),
-          resolvedJs.replace(/\\.js$/, ".tsx")
-        ];
-        let targetTs;
-        for (const candidate of tsCandidates) {
-          if (await pathExists(candidate)) {
-            targetTs = candidate;
-            break;
-          }
-        }
-        if (targetTs) {
-          const relImport = normalizePath(path4.relative(path4.dirname(resolvedJs), targetTs));
-          const importPath = relImport.startsWith(".") ? relImport : `./${relImport}`;
-          const shim = `export * from '${importPath}'
-import * as __all from '${importPath}'
-export default ('default' in __all ? __all.default : __all)
-`;
-          await fs2.mkdir(path4.dirname(resolvedJs), { recursive: true });
-          await fs2.writeFile(resolvedJs, shim, "utf8");
-          shimWrites.push(resolvedJs);
-        }
-        match = regex.exec(content);
+      if (entry.isFile()) {
+        files.push(target);
       }
     }
+  };
+  if (await pathExists(rootDir)) {
+    await walk(rootDir);
+  }
+  return files;
+}
+function suffixMatchScore(candidate, wanted) {
+  const left = normalizePath(candidate).split("/");
+  const right = normalizePath(wanted).split("/");
+  let score = 0;
+  while (score < left.length && score < right.length) {
+    const a = left[left.length - 1 - score];
+    const b = right[right.length - 1 - score];
+    if (a !== b) break;
+    score += 1;
+  }
+  return score;
+}
+async function resolveEmittedEntryPath(emitRoot, moduleRel) {
+  const expected = path4.resolve(emitRoot, toEmittedModulePath(moduleRel));
+  if (await pathExists(expected)) {
+    return expected;
+  }
+  const wantedRel = toEmittedModulePath(moduleRel);
+  const wantedBase = path4.posix.basename(normalizePath(wantedRel));
+  const files = await collectFilesRecursive(emitRoot);
+  const candidates = files.filter(
+    (file) => path4.posix.basename(normalizePath(file)) === wantedBase
+  );
+  if (candidates.length === 0) {
+    return void 0;
   }
-  return shimWrites;
+  candidates.sort(
+    (a, b) => suffixMatchScore(b, wantedRel) - suffixMatchScore(a, wantedRel)
+  );
+  return candidates[0];
 }
-async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
+async function compileSnapshotEntry(options) {
+  const log = options.log ?? (() => void 0);
+  const tsconfigStat = await fs2.stat(options.tsconfigPath);
+  const cacheKey = buildCompileCacheKey(
+    options.commitSha,
+    options.moduleRel,
+    options.tsconfigPath,
+    { mtimeMs: tsconfigStat.mtimeMs, size: tsconfigStat.size }
+  );
+  const emitRoot = path4.join(options.cacheRoot, cacheKey, "dist");
+  let emittedEntry = path4.resolve(emitRoot, toEmittedModulePath(options.moduleRel));
+  if (!options.noCache && await pathExists(emittedEntry)) {
+    log(`[changelog] compile cache hit: ${options.commitSha.slice(0, 12)}`);
+    return emittedEntry;
+  }
+  log(
+    `[changelog] compile cache ${options.noCache ? "disabled" : "miss"}: ${options.commitSha.slice(0, 12)}`
+  );
+  await fs2.rm(path4.join(options.cacheRoot, cacheKey), { recursive: true, force: true }).catch(
+    () => void 0
+  );
+  await fs2.mkdir(emitRoot, { recursive: true });
+  const readResult = ts2.readConfigFile(options.tsconfigPath, ts2.sys.readFile);
+  if (readResult.error) {
+    throw new Error(ts2.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
+  }
+  const parsed = ts2.parseJsonConfigFileContent(
+    readResult.config,
+    ts2.sys,
+    path4.dirname(options.tsconfigPath)
+  );
+  const compilerOptions = {
+    ...parsed.options,
+    noEmit: false,
+    declaration: false,
+    declarationMap: false,
+    sourceMap: false,
+    inlineSourceMap: false,
+    composite: false,
+    incremental: false,
+    tsBuildInfoFile: void 0,
+    outDir: emitRoot
+  };
+  const program = ts2.createProgram([options.modulePath], compilerOptions);
+  const emitResult = program.emit();
+  const diagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics).filter((diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error);
+  if (diagnostics.length > 0) {
+    const host = {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => options.worktreeDir,
+      getNewLine: () => "\n"
+    };
+    const message = ts2.formatDiagnosticsWithColorAndContext(diagnostics.slice(0, 20), host);
+    throw new Error(
+      `TypeScript snapshot compile failed for ${options.moduleRel} at ${options.commitSha.slice(0, 12)}:
+${message}`
+    );
+  }
+  emittedEntry = await resolveEmittedEntryPath(emitRoot, options.moduleRel) ?? emittedEntry;
+  if (!await pathExists(emittedEntry)) {
+    throw new Error(
+      `Compiled snapshot entry was not emitted: ${emittedEntry}. Check module/tsconfig compatibility.`
+    );
+  }
+  log(`[changelog] compiled snapshot entry: ${emittedEntry}`);
+  return emittedEntry;
+}
+async function loadSnapshotExport(options) {
+  return loadChangelogInput(options.entryPath, options.exportName);
+}
+async function createSnapshot(repoRoot, moduleCandidates, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
   const worktreeDir = path4.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
   await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
   try {
     await ensureWorktreeDependencies(repoRoot, worktreeDir);
-    const shimmedFiles = await createMissingJsImportShims(worktreeDir);
-    if (shimmedFiles.length > 0) {
+    const resolvedModuleRel = await resolveModulePathForCommit(
+      repoRoot,
+      commit.sha,
+      moduleCandidates
+    );
+    if (!resolvedModuleRel) {
       log?.(
-        `[changelog] created ${shimmedFiles.length} missing .js import shim(s) in ${commit.sha.slice(0, 12)}`
+        `[changelog] unresolved module for commit ${commit.sha.slice(0, 12)}; using empty snapshot`
       );
+      return {
+        commit,
+        routesByKey: {},
+        sourceObjectsById: {},
+        unresolvedModule: true
+      };
     }
-    const modulePath = path4.resolve(worktreeDir, moduleRel);
-    const tsconfigPath = tsconfigRel ? path4.resolve(worktreeDir, tsconfigRel) : void 0;
-    const input = await loadChangelogInput(modulePath, exportName);
+    log?.(
+      `[changelog] resolved module for commit ${commit.sha.slice(0, 12)}: ${resolvedModuleRel}`
+    );
+    const modulePath = path4.resolve(worktreeDir, resolvedModuleRel);
+    let snapshotRuntimePath = modulePath;
+    let resolvedTsconfigPath;
+    if (isTypeScriptModule(modulePath)) {
+      resolvedTsconfigPath = await resolveSnapshotTsconfig(
+        worktreeDir,
+        modulePath,
+        tsconfigRel
+      );
+      log?.(`[changelog] using tsconfig: ${resolvedTsconfigPath}`);
+      const compileCacheRoot = path4.resolve(
+        exportOptions?.cacheDir ?? path4.join(os.tmpdir(), "rrroutes-export-changelog-cache")
+      );
+      snapshotRuntimePath = await compileSnapshotEntry({
+        worktreeDir,
+        moduleRel: resolvedModuleRel,
+        modulePath,
+        tsconfigPath: resolvedTsconfigPath,
+        commitSha: commit.sha,
+        cacheRoot: compileCacheRoot,
+        noCache: exportOptions?.noCache,
+        log
+      });
+    } else if (!isJavaScriptModule(modulePath)) {
+      throw new Error(
+        `Unsupported module extension for changelog snapshots: ${modulePath}`
+      );
+    }
+    const input = await loadSnapshotExport({
+      entryPath: snapshotRuntimePath,
+      exportName
+    });
     const payload = await exportFinalizedLeaves(input, {
       includeSource: true,
       sourceModulePath: modulePath,
       sourceExportName: exportName,
-      tsconfigPath,
-      ...exportOptions
+      tsconfigPath: resolvedTsconfigPath ?? (tsconfigRel ? path4.resolve(worktreeDir, tsconfigRel) : void 0),
+      handlers: exportOptions?.handlers
     });
     const routesByKey = toRouteSnapshots(payload);
     const sourceObjectsById = toSourceObjectSnapshots(routesByKey);
@@ -2149,12 +2358,18 @@ async function exportFinalizedLeavesChangelog(options) {
   log("[changelog] resolving commit window");
   const window = await resolveCommitWindow(repoRoot, options.from, options.to);
   log(`[changelog] window: ${window.from.slice(0, 12)}..${window.to.slice(0, 12)}`);
+  const moduleCandidates = await buildModulePathCandidates(
+    repoRoot,
+    window.to,
+    modulePathRelative
+  );
+  log(`[changelog] module candidates discovered: ${moduleCandidates.length}`);
   const allCommits = await resolveCommitPath(repoRoot, window.from, window.to);
   log(`[changelog] commits in ancestry path: ${allCommits.length}`);
   const selectedCommitShas = await filterCommits(
     repoRoot,
     allCommits,
-    modulePathRelative,
+    moduleCandidates,
     tsconfigRelative
   );
   log(`[changelog] commits after path filter: ${selectedCommitShas.length}`);
@@ -2171,6 +2386,7 @@ async function exportFinalizedLeavesChangelog(options) {
   log(`[changelog] temp workspace: ${tempRoot}`);
   try {
     const snapshots = [];
+    const unresolvedModuleCommits = [];
     for (let index = 0; index < commits.length; index += 1) {
       const commit = commits[index];
       log(
@@ -2179,7 +2395,7 @@ async function exportFinalizedLeavesChangelog(options) {
       snapshots.push(
         await createSnapshot(
           repoRoot,
-          modulePathRelative,
+          moduleCandidates,
           exportName,
           commit,
           tempRoot,
@@ -2188,6 +2404,9 @@ async function exportFinalizedLeavesChangelog(options) {
           log
         )
       );
+      if (snapshots[snapshots.length - 1]?.unresolvedModule) {
+        unresolvedModuleCommits.push(commit.sha);
+      }
     }
     const routeEvents = [];
     const sourceEvents = [];
@@ -2212,7 +2431,8 @@ async function exportFinalizedLeavesChangelog(options) {
         exportName,
         from: window.from,
         to: window.to,
-        selectedCommitCount: commits.length
+        selectedCommitCount: commits.length,
+        unresolvedModuleCommits: unresolvedModuleCommits.length > 0 ? unresolvedModuleCommits : void 0
       },
       commits,
       byRoute: routeRecordByKey(routeEvents),
@@ -2239,6 +2459,13 @@ var __private = {
   resolveCommitWindow,
   resolveCommitPath,
   filterCommits,
+  buildModulePathCandidates,
+  resolveModulePathForCommit,
+  resolveSnapshotTsconfig,
+  toEmittedModulePath,
+  buildCompileCacheKey,
+  compileSnapshotEntry,
+  loadSnapshotExport,
   toRouteSnapshots,
   toSourceObjectSnapshots,
   diffSnapshots,
@@ -2249,6 +2476,7 @@ var __private = {
 import path5 from "path";
 function parseFinalizedLeavesChangelogCliArgs(argv) {
   const args = /* @__PURE__ */ new Map();
+  let noCache = false;
   for (let i = 0; i < argv.length; i += 1) {
     const key = argv[i];
     if (key === "--") continue;
@@ -2256,6 +2484,10 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     if (key === "--with-source") {
       continue;
     }
+    if (key === "--no-cache") {
+      noCache = true;
+      continue;
+    }
     const value = argv[i + 1];
     if (!value || value.startsWith("--")) {
       throw new Error(`Missing value for ${key}`);
@@ -2274,7 +2506,9 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     htmlFile: args.get("--html") ?? void 0,
     tsconfigPath: args.get("--tsconfig") ?? void 0,
     from: args.get("--from") ?? void 0,
-    to: args.get("--to") ?? void 0
+    to: args.get("--to") ?? void 0,
+    cacheDir: args.get("--cache-dir") ?? void 0,
+    noCache
   };
 }
 async function runExportFinalizedLeavesChangelogCli(argv) {
@@ -2292,6 +2526,8 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
     from: args.from,
     to: args.to,
     includeSource: true,
+    cacheDir: args.cacheDir,
+    noCache: args.noCache,
     log
   };
   log("[changelog-cli] starting changelog export");