submodule-version 2.3.2 → 3.0.0

package/src/git/local/local.ts

@@ -0,0 +1,430 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import { parseGitUrl } from '../parseGitUrl';
+import { versionUtil } from '../../versionUtil';
+import { RunOptions } from '../../runOptions';
+import { GitError } from '../GitError';
+
+const execAsync = promisify(exec);
+
+/* stderr упавшей git-команды — единственный источник настоящей причины */
+const stderrOf = (error: unknown): string => (
+  (error as { stderr?: string })?.stderr || ''
+).trim();
+
+export const local = {
+  addSubmodule: async (url: string): Promise<void> => {
+    const { name } = parseGitUrl(url);
+    const module = path.join(RunOptions.modulesDir, name);
+
+    try {
+      await execAsync(
+        `git submodule add "${url}" "${module}"`,
+        { cwd: RunOptions.cwd },
+      );
+    } catch (error) {
+      throw new GitError('GIT_SUBMODULE_ADD_FAILED', {
+        url,
+        reason: stderrOf(error),
+      });
+    }
+  },
+
+  checkout: async (name: string, version: string): Promise<void> => {
+    const module = path.join(RunOptions.modulesDir, name);
+
+    try {
+      await execAsync(
+        `git -C "${module}" checkout ${version} -q`,
+        { cwd: RunOptions.cwd },
+      );
+    } catch (error) {
+      throw new GitError('GIT_MODULE_CHECKOUT_FAILED', {
+        name,
+        version,
+        reason: stderrOf(error),
+      });
+    }
+  },
+
+  listVersions: async (projectName: string): Promise<string[]> => {
+    const module = path.join(RunOptions.modulesDir, projectName);
+
+    return local.listTags(module);
+  },
+
+  status: async (dir: string): Promise<string> => {
+    const res = await execAsync(
+      `git -C "${dir}" status --porcelain`,
+      { cwd: RunOptions.cwd },
+    );
+
+    return res.stdout.toString();
+  },
+
+  hasChanges: async (dir: string): Promise<boolean> => {
+    const status = await local.status(dir);
+
+    return status.trim().length > 0;
+  },
+
+  hasUnpushedCommits: async (dir: string): Promise<boolean> => {
+    await local.fetch(dir);
+
+    const branch = await local.currentBranch(dir);
+
+    if (branch) {
+      let upstream: string | null = null;
+
+      try {
+        const res = await execAsync(
+          `git -C "${dir}" rev-parse --abbrev-ref --symbolic-full-name @{u}`,
+          { cwd: RunOptions.cwd },
+        );
+
+        upstream = res.stdout.toString().trim() || null;
+      } catch {
+        upstream = null;
+      }
+
+      if (!upstream) {
+        try {
+          await execAsync(
+            `git -C "${dir}" rev-parse --verify --quiet origin/${branch}`,
+            { cwd: RunOptions.cwd },
+          );
+          upstream = `origin/${branch}`;
+        } catch {
+          upstream = null;
+        }
+      }
+
+      /* Ветки на remote нет — всё локальное не опубликовано */
+      if (!upstream) return true;
+
+      const res = await execAsync(
+        `git -C "${dir}" rev-list ${upstream}..HEAD --count`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return Number(res.stdout.toString().trim()) > 0;
+    }
+
+    /*
+     * Detached HEAD (checkout на тег): локальные теги не доказывают публикацию
+     * (могут быть не запушены) — сверяем HEAD с фактическими рефами remote.
+     */
+    let remoteOutput = '';
+
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" ls-remote origin`,
+        { cwd: RunOptions.cwd },
+      );
+
+      remoteOutput = res.stdout.toString();
+    } catch {
+      /* Remote недоступен/не настроен — считаем всё неопубликованным */
+      return true;
+    }
+
+    const remoteShas = remoteOutput.split(/\r?\n/)
+      .map(line => line.split(/\s+/)[0])
+      .filter(sha => /^[0-9a-f]{40}$/.test(sha));
+
+    for (const sha of remoteShas) {
+      try {
+        await execAsync(
+          `git -C "${dir}" merge-base --is-ancestor HEAD ${sha}`,
+          { cwd: RunOptions.cwd },
+        );
+
+        /* HEAD достижим из remote-рефа — опубликован */
+        return false;
+      } catch {
+        // HEAD не предок этого рефа — проверяем остальные
+      }
+    }
+
+    return true;
+  },
+
+  isGitRepo: async (dir: string): Promise<boolean> => {
+    try {
+      await execAsync(
+        `git -C "${dir}" rev-parse --is-inside-work-tree`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  getRemote: async (dir: string): Promise<string | null> => {
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" remote get-url origin`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return res.stdout.toString().trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  init: async (dir: string): Promise<void> => {
+    await execAsync(
+      `git -C "${dir}" init`,
+      { cwd: RunOptions.cwd },
+    );
+  },
+
+  addRemote: async (dir: string, url: string): Promise<void> => {
+    const existing = await local.getRemote(dir);
+
+    const command = existing
+      ? `git -C "${dir}" remote set-url origin "${url}"`
+      : `git -C "${dir}" remote add origin "${url}"`;
+
+    await execAsync(command, { cwd: RunOptions.cwd });
+  },
+
+  currentBranch: async (dir: string): Promise<string | null> => {
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" symbolic-ref --short -q HEAD`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return res.stdout.toString().trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  defaultRemoteBranch: async (dir: string): Promise<string | null> => {
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" symbolic-ref --short refs/remotes/origin/HEAD`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return res.stdout.toString().trim().replace(/^origin\//, '') || null;
+    } catch {
+      // origin/HEAD not set - probe common defaults
+    }
+
+    for (const candidate of ['main', 'master']) {
+      try {
+        await execAsync(
+          `git -C "${dir}" rev-parse --verify --quiet origin/${candidate}`,
+          { cwd: RunOptions.cwd },
+        );
+
+        return candidate;
+      } catch {
+        // No such remote branch
+      }
+    }
+
+    return null;
+  },
+
+  /*
+   * Аддоны checkout'нуты на тег (detached HEAD). Перед коммитом поднимаем
+   * локальную ветку на текущем коммите и привязываем её к remote-ветке,
+   * чтобы sync/push работали по ветке, а не в оторванной голове.
+   */
+  ensureBranch: async (dir: string): Promise<void> => {
+    const branch = await local.currentBranch(dir);
+    if (branch) return;
+
+    await local.fetch(dir);
+    const remoteBranch = await local.defaultRemoteBranch(dir);
+    const target = remoteBranch || 'main';
+
+    await execAsync(
+      `git -C "${dir}" checkout -B ${target}`,
+      { cwd: RunOptions.cwd },
+    );
+
+    if (remoteBranch) {
+      await execAsync(
+        // eslint-disable-next-line max-len
+        `git -C "${dir}" branch --set-upstream-to=origin/${remoteBranch} ${target}`,
+        { cwd: RunOptions.cwd },
+      );
+    }
+  },
+
+  commitAll: async (dir: string, message: string): Promise<void> => {
+    await execAsync(
+      `git -C "${dir}" add -A`,
+      { cwd: RunOptions.cwd },
+    );
+
+    await execAsync(
+      `git -C "${dir}" commit -m ${JSON.stringify(message)}`,
+      { cwd: RunOptions.cwd },
+    );
+  },
+
+  addTag: async (dir: string, version: string): Promise<void> => {
+    await execAsync(
+      `git -C "${dir}" tag ${version}`,
+      { cwd: RunOptions.cwd },
+    );
+  },
+
+  push: async (dir: string, tag?: string): Promise<void> => {
+    await execAsync(
+      `git -C "${dir}" push -u origin HEAD`,
+      { cwd: RunOptions.cwd },
+    );
+
+    if (tag) {
+      await execAsync(
+        `git -C "${dir}" push origin ${tag}`,
+        { cwd: RunOptions.cwd },
+      );
+    }
+  },
+
+  fetch: async (dir: string): Promise<void> => {
+    try {
+      await execAsync(
+        `git -C "${dir}" fetch origin`,
+        { cwd: RunOptions.cwd },
+      );
+    } catch {
+      // Fresh repo without upstream yet - nothing to fetch
+    }
+  },
+
+  isRemoteAhead: async (dir: string): Promise<boolean> => {
+    await local.fetch(dir);
+
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" rev-list HEAD..@{u} --count`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return Number(res.stdout.toString().trim()) > 0;
+    } catch {
+      // No upstream configured - remote is not ahead
+      return false;
+    }
+  },
+
+  pullRebaseAutostash: async (dir: string): Promise<void> => {
+    try {
+      await execAsync(
+        `git -C "${dir}" pull --rebase --autostash`,
+        { cwd: RunOptions.cwd },
+      );
+    } catch {
+      try {
+        await execAsync(
+          `git -C "${dir}" rebase --abort`,
+          { cwd: RunOptions.cwd },
+        );
+      } catch {
+        // Best effort - no rebase in progress
+      }
+
+      try {
+        await execAsync(
+          `git -C "${dir}" stash pop`,
+          { cwd: RunOptions.cwd },
+        );
+      } catch {
+        // Best effort - nothing stashed
+      }
+
+      throw new GitError('GIT_SYNC_CONFLICT');
+    }
+  },
+
+  tagsAtHead: async (dir: string): Promise<string[]> => {
+    try {
+      const res = await execAsync(
+        `git -C "${dir}" tag --points-at HEAD`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return res.stdout.toString().split(/\r?\n/)
+        .filter(tag => tag && versionUtil.validate(tag));
+    } catch {
+      return [];
+    }
+  },
+
+  currentVersion: async (name: string): Promise<string | null> => {
+    const module = path.join(RunOptions.modulesDir, name);
+    const tags = await local.tagsAtHead(module);
+
+    return versionUtil.latest(tags) || null;
+  },
+
+  listTags: async (dir: string): Promise<string[]> => {
+    try {
+      await execAsync(
+        `git -C "${dir}" fetch --tags`,
+        { cwd: RunOptions.cwd },
+      );
+    } catch {
+      // Repo without remote - local tags only
+    }
+
+    const res = await execAsync(
+      `git -C "${dir}" tag -l`,
+      { cwd: RunOptions.cwd },
+    );
+
+    const tagList = res.stdout.toString().split(/\r?\n/);
+
+    return tagList.filter(tag => {
+      if (!tag) return false;
+
+      return versionUtil.validate(tag);
+    });
+  },
+
+  /*
+   * package.json сабмодуля на произвольном рефе (теге), не трогая рабочую
+   * копию. Нет файла или рефа — null (ленивое чтение depsByVersion).
+   */
+  readJSONAtRef: async (name: string, ref: string): Promise<any | null> => {
+    const module = path.join(RunOptions.modulesDir, name);
+
+    try {
+      const res = await execAsync(
+        `git -C "${module}" show ${ref}:package.json`,
+        { cwd: RunOptions.cwd },
+      );
+
+      return JSON.parse(res.stdout.toString());
+    } catch {
+      return null;
+    }
+  },
+
+  rm: async (submoduleName: string) => {
+    const modulePath = path.join(RunOptions.modulesDir, submoduleName);
+
+    await execAsync(
+      `git rm -rf "${modulePath}"`,
+      { cwd: RunOptions.cwd },
+    );
+
+    await execAsync(
+      `rm -rf "${path.join('.git/modules', modulePath)}"`,
+      { cwd: RunOptions.cwd },
+    );
+  },
+};

package/src/index.ts

@@ -1,2 +1,19 @@
 export { SV } from './sv';
 export { versionUtil } from './versionUtil';
+export { PubGrub, pubGrub } from './PubGrub';
+export type {
+  IEntrySource,
+  IIncompatibility,
+  IOverride,
+  IPackageEntry,
+  IRequirement,
+  IResolvedPackage,
+  ITerm,
+  TDependencies,
+  TPubGrubResult,
+} from './PubGrub';
+export { EntryStore, entryStore } from './entryStore';
+export { printError } from './printError';
+export { git, GitError, GithubError } from './git';
+export { SVError, ERR } from './errors';
+export type { TSVErrorCode, TSVErrorDetails } from './errors';

package/src/printError.ts

@@ -0,0 +1,189 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { ERR, SVError } from './errors';
+import { GitError, GithubError } from './git';
+import { RunOptions } from './runOptions';
+import { versionUtil } from './versionUtil';
+
+const ROOT = '<root>';
+
+const asList = (value: unknown): string[] => (
+  Array.isArray(value) ? value.map(String) : []
+);
+
+/* Имя проекта из корневого package.json для отображения вместо <root> */
+const projectRootName = (): string => {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(path.join(RunOptions.cwd, 'package.json'), 'utf-8'),
+    );
+
+    return pkg.name || 'the project root';
+  } catch {
+    return 'the project root';
+  }
+};
+
+const printVersionConflict = (
+  details: Record<string, unknown>,
+): string => {
+  const parents = (details.parents || {}) as Record<string, string>;
+  const versions = asList(details.versions);
+
+  const constraints = (
+    Array.isArray(details.constraints) ? details.constraints : []
+  ) as Array<{
+    range: string,
+    positive: boolean,
+    requiredBy: string,
+  }>;
+
+  /*
+   * Ни одна доступная версия не подходит под одно из требований —
+   * это не конфликт между родителями, а запрос несуществующей версии.
+   */
+  const unsatisfiable = constraints.find(requirement => (
+    requirement.positive
+    && !versions.some(version => (
+      versionUtil.satisfies(version, requirement.range)
+    ))
+  ));
+
+  if (unsatisfiable) {
+    const from = unsatisfiable.requiredBy === ROOT
+      ? projectRootName()
+      : unsatisfiable.requiredBy;
+
+    return `Package ${String(details.name)} does not contain a version`
+      + ` matching ${unsatisfiable.range} required by ${from}`
+      + `. Use one of [${versions.join(', ')}]`;
+  }
+
+  const chain = asList(details.chain)
+    .map(name => (name === ROOT ? projectRootName() : name));
+
+  const lines = [
+    `Version conflict for ${String(details.name)}:`,
+    ...Object.entries(parents).map(([parent, range]) => {
+      const from = parent === ROOT ? projectRootName() : parent;
+
+      return `  - ${range} required by ${from}`;
+    }),
+  ];
+
+  if (chain.length) lines.push(`  chain: ${chain.join(' -> ')}`);
+
+  if (versions.length) {
+    lines.push(`  available versions: ${versions.join(', ')}`);
+  }
+
+  return lines.join('\n');
+};
+
+const printSVError = (error: SVError): string => {
+  const { error: code, details } = error;
+
+  switch (code) {
+    case ERR.NOT_A_NPM:
+      return 'Not an npm project (package.json not found)';
+    case ERR.NOT_A_GIT_REPO:
+      return 'Not a git repository';
+    case ERR.NOT_A_GIT_URL:
+      return `${String(details.url || '')} - is not a git url!`;
+    case ERR.NOT_INITIALIZED:
+      return 'SV is not initialized - call init() first';
+    case ERR.NOT_IMPLEMENTED:
+      return 'This command is not implemented yet';
+    case ERR.PATH_NOT_FOUND:
+      return `Path ${String(details.path)} is not found`;
+    case ERR.ADDON_NOT_FOUND: {
+      const urls = asList(details.urls);
+
+      const suffix = urls.length
+        ? ` (conflicting urls: ${urls.join(', ')})`
+        : '';
+
+      return `Module ${String(details.name)} is not found${suffix}`;
+    }
+    case ERR.REQUESTED_VERSION_NOT_EXISTS: {
+      const versions = asList(details.versions).join(', ');
+
+      return `Package ${String(details.name)} does not contain version`
+        + ` ${String(details.requestedVersion)}. Use one of [${versions}]`;
+    }
+    case ERR.VERSION_CONFLICT:
+      return printVersionConflict(details);
+    case ERR.CIRCULAR_DEPENDENCY:
+      return `Circular dependency: ${asList(details.chain).join(' -> ')}`;
+    case ERR.UNKNOWN_VERSION:
+      return `Unknown version ${String(details.version)}`
+        + ` for ${String(details.name)} in ${String(details.parent)}`;
+    case ERR.GIT_DIRTY_SWITCH_CONFLICT:
+      return 'Checkout failed: uncommitted changes cannot be carried over'
+        + ' - move them manually';
+    default:
+      return code;
+  }
+};
+
+const printGitError = (error: GitError): string => {
+  const reason = error.details.reason
+    ? `: ${String(error.details.reason)}`
+    : '';
+
+  switch (error.message) {
+    case 'GIT_NOT_A_REPO':
+      return 'Not a git repository';
+    case 'GIT_SUBMODULE_ADD_FAILED':
+      return `Failed to add submodule ${String(error.details.url)}${reason}`;
+    case 'GIT_MODULE_CHECKOUT_FAILED':
+      return `Checkout ${String(error.details.version || '')}`
+        + ` failed${reason}`;
+    case 'GIT_REPO_URL_REQUIRED':
+      return 'Module is not published yet'
+        + ' - pass --repo-url for the first publish';
+    case 'GIT_NOT_LATEST_VERSION':
+      return 'Publish is only possible from the latest version';
+    case 'GIT_SYNC_CONFLICT':
+      return 'Sync with remote failed - resolve conflicts manually';
+    default:
+      return error.message;
+  }
+};
+
+const printGithubError = (error: GithubError): string => {
+  const { message, details } = error;
+
+  switch (message) {
+    case 'GITHUB_NOT_A_REPO_URL':
+      return `Not a GitHub repo url: ${String(details.url)}`;
+    case 'GITHUB_TOKEN_REQUIRED':
+      return 'GitHub GraphQL API requires a token: set GITHUB_TOKEN'
+        + ' or pass { githubToken } to new SV()';
+    case 'GITHUB_API_FAILED': {
+      const hints: Record<number, string> = {
+        404: 'repo not found or private (set GITHUB_TOKEN)',
+        403: 'rate limit or forbidden (set GITHUB_TOKEN)',
+      };
+
+      const status = details.status as number;
+      const hint = hints[status];
+      const target = details.url ? ` for ${String(details.url)}` : '';
+      const errors = asList(details.errors).join('; ');
+
+      return `GitHub API failed (${status})${target}`
+        + `${errors ? `: ${errors}` : ''}${hint ? `: ${hint}` : ''}`;
+    }
+    default:
+      return message;
+  }
+};
+
+/* Человекочитаемый текст ошибок SV/PubGrub, git-слоя и GitHub API */
+export const printError = (error: Error): string => {
+  if (error instanceof SVError) return printSVError(error);
+  if (error instanceof GitError) return printGitError(error);
+  if (error instanceof GithubError) return printGithubError(error);
+
+  return `Unhandled error: ${error.message}`;
+};