cabloy 5.1.219 → 5.1.221

package/zova/packages-cli/cli-set-front/src/lib/common/restDependencyVersions.ts

@@ -0,0 +1,252 @@
+import fse from 'fs-extra';
+import path from 'node:path';
+import yaml from 'yaml';
+
+const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies'] as const;
+
+type ImporterDependency = {
+  specifier?: string;
+  version?: string;
+};
+
+type Importer = Partial<
+  Record<(typeof dependencySections)[number], Record<string, ImporterDependency>>
+>;
+
+type ParsedLockfile = {
+  importers?: Record<string, Importer>;
+};
+
+type ModuleCandidate = {
+  range: string;
+  moduleRoot: string;
+};
+
+export async function extractRestDependencyVersions(
+  projectPath: string,
+  deps: string[],
+  moduleRoots: string[] = [],
+): Promise<Record<string, string>> {
+  const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
+  const lockfileContent = await fse.readFile(lockfilePath, 'utf8');
+  const parsedLockfile = parseWorkspaceLockfile(lockfileContent);
+  const depsVersion: Record<string, string> = {};
+
+  for (const dep of deps) {
+    const rootRange = getPackageDependencyRangeFromLock(parsedLockfile, dep);
+    if (rootRange) {
+      depsVersion[dep] = rootRange;
+      continue;
+    }
+
+    const moduleCandidates = await getModuleCandidates(
+      projectPath,
+      parsedLockfile,
+      dep,
+      moduleRoots,
+    );
+    const distinctCandidates = getDistinctCandidates(moduleCandidates);
+    if (distinctCandidates.length > 1) {
+      throw createConflictingCandidatesError(dep, distinctCandidates);
+    }
+    if (distinctCandidates.length === 1) {
+      depsVersion[dep] = distinctCandidates[0].range;
+      continue;
+    }
+
+    const rootVersion = await getPackageVersionFromNodeModules(projectPath, dep);
+    if (rootVersion) {
+      depsVersion[dep] = `^${rootVersion}`;
+      continue;
+    }
+
+    throw createUnresolvedDependencyError(projectPath, dep, moduleRoots);
+  }
+
+  return depsVersion;
+}
+
+function parseWorkspaceLockfile(content: string): ParsedLockfile {
+  const documents = yaml.parseAllDocuments(content);
+  for (const document of documents) {
+    if (document.errors.length) throw document.errors[0];
+  }
+
+  // pnpm 12 places the workspace lock after its package-manager/config dependency lock.
+  const document = documents.findLast(({ contents }) => {
+    return (
+      contents !== null &&
+      !(yaml.isScalar(contents) && contents.value === null && contents.source === '')
+    );
+  });
+  if (!document || !yaml.isMap(document.contents) || !yaml.isMap(document.get('importers', true))) {
+    throw new Error(
+      'Invalid pnpm-lock.yaml: expected a workspace document with an importers mapping.',
+    );
+  }
+  return document.toJS() as ParsedLockfile;
+}
+
+function getPackageDependencyRangeFromLock(
+  parsedLockfile: ParsedLockfile,
+  packageName: string,
+): string | null {
+  const importer = parsedLockfile.importers?.['.'];
+  return getImporterDependencyRange(importer, packageName);
+}
+
+function getImporterDependencyRange(
+  importer: Importer | undefined,
+  packageName: string,
+): string | null {
+  if (!importer) return null;
+
+  for (const section of dependencySections) {
+    const dependencyRange = normalizeImporterDependency(importer[section]?.[packageName]);
+    if (dependencyRange) return dependencyRange;
+  }
+  return null;
+}
+
+function normalizeImporterDependency(
+  importerDependency: ImporterDependency | undefined,
+): string | null {
+  if (!importerDependency) return null;
+
+  const specifier = importerDependency.specifier;
+  if (specifier?.startsWith('npm:')) return specifier;
+
+  const version = normalizeLockfileVersion(importerDependency.version);
+  if (!version) return null;
+  return `^${version}`;
+}
+
+function normalizeLockfileVersion(version: string | undefined): string | null {
+  if (!version) return null;
+  if (version.startsWith('link:') || version.startsWith('file:')) return null;
+
+  const versionWithoutPeers = version.split('(')[0];
+  if (!versionWithoutPeers) return null;
+  if (/^\d/.test(versionWithoutPeers)) return versionWithoutPeers;
+
+  const aliasSeparator = versionWithoutPeers.lastIndexOf('@');
+  if (aliasSeparator === -1) return null;
+
+  const aliasedVersion = versionWithoutPeers.slice(aliasSeparator + 1);
+  if (!aliasedVersion || !/^\d/.test(aliasedVersion)) return null;
+  return aliasedVersion;
+}
+
+async function getModuleCandidates(
+  projectPath: string,
+  parsedLockfile: ParsedLockfile,
+  packageName: string,
+  moduleRoots: string[],
+): Promise<ModuleCandidate[]> {
+  const candidates: ModuleCandidate[] = [];
+  for (const moduleRoot of moduleRoots) {
+    const absoluteModuleRoot = path.resolve(projectPath, moduleRoot);
+    if (absoluteModuleRoot === path.resolve(projectPath)) continue;
+
+    const importerKey = getImporterKey(projectPath, absoluteModuleRoot);
+    const importerRange = getImporterDependencyRange(
+      parsedLockfile.importers?.[importerKey],
+      packageName,
+    );
+    if (importerRange) {
+      candidates.push({ range: importerRange, moduleRoot: importerKey });
+      continue;
+    }
+
+    const manifestSpecifier = await getManifestDependencySpecifier(absoluteModuleRoot, packageName);
+    if (!manifestSpecifier) continue;
+
+    const installedVersion = await getPackageVersionFromNodeModules(
+      absoluteModuleRoot,
+      packageName,
+    );
+    if (!installedVersion) continue;
+    candidates.push({
+      range: manifestSpecifier.startsWith('npm:') ? manifestSpecifier : `^${installedVersion}`,
+      moduleRoot: importerKey,
+    });
+  }
+  return candidates;
+}
+
+async function getManifestDependencySpecifier(
+  moduleRoot: string,
+  packageName: string,
+): Promise<string | null> {
+  const manifestPath = path.join(moduleRoot, 'package.json');
+  if (!fse.existsSync(manifestPath)) return null;
+
+  const manifest = (await fse.readJson(manifestPath)) as Record<string, unknown>;
+  for (const section of dependencySections) {
+    const sectionDependencies = manifest[section];
+    if (!sectionDependencies || typeof sectionDependencies !== 'object') continue;
+    const specifier = (sectionDependencies as Record<string, unknown>)[packageName];
+    if (typeof specifier === 'string') return specifier;
+  }
+  return null;
+}
+
+function getDistinctCandidates(candidates: ModuleCandidate[]): ModuleCandidate[] {
+  const distinctCandidates = new Map<string, ModuleCandidate>();
+  for (const candidate of candidates) {
+    if (!distinctCandidates.has(candidate.range)) {
+      distinctCandidates.set(candidate.range, candidate);
+    }
+  }
+  return Array.from(distinctCandidates.values());
+}
+
+async function getPackageVersionFromNodeModules(
+  packageRoot: string,
+  packageName: string,
+): Promise<string | null> {
+  const pkgFile = path.join(packageRoot, 'node_modules', packageName, 'package.json');
+  if (!fse.existsSync(pkgFile)) return null;
+  const pkgContent = (await fse.readJson(pkgFile)) as Record<string, unknown>;
+  return typeof pkgContent.version === 'string' && pkgContent.version ? pkgContent.version : null;
+}
+
+function getImporterKey(projectPath: string, moduleRoot: string): string {
+  const relativePath = path.relative(projectPath, moduleRoot);
+  return relativePath.replaceAll(path.sep, '/') || '.';
+}
+
+function getRepoRelativePath(projectPath: string, filePath: string): string {
+  const relativePath = path.relative(projectPath, filePath).replaceAll(path.sep, '/');
+  return relativePath || '.';
+}
+
+function createConflictingCandidatesError(
+  packageName: string,
+  candidates: ModuleCandidate[],
+): Error {
+  const details = candidates
+    .map(candidate => `${candidate.moduleRoot} (${candidate.range})`)
+    .join(', ');
+  return new Error(
+    `Conflicting REST dependency versions for ${packageName} in module importers: ${details}. ` +
+      `Align the dependency versions or declare ${packageName} in the project root package.json ` +
+      '(pnpm-lock.yaml).',
+  );
+}
+
+function createUnresolvedDependencyError(
+  projectPath: string,
+  packageName: string,
+  moduleRoots: string[],
+): Error {
+  const checkedModuleRoots = moduleRoots.length
+    ? moduleRoots
+        .map(moduleRoot => getRepoRelativePath(projectPath, path.resolve(projectPath, moduleRoot)))
+        .join(', ')
+    : '(none)';
+  return new Error(
+    `Unable to resolve REST dependency version for ${packageName}. Add it to the project or an owning ` +
+      `module and install it; checked module roots: ${checkedModuleRoots}; lockfile: pnpm-lock.yaml.`,
+  );
+}