submodule-version 2.1.3 → 2.3.0

package/src/git/git.ts

@@ -40,10 +40,339 @@ export const git = {
 
   listVersions: async (projectName: string): Promise<string[]> => {
     const module = path.join(RunOptions.modulesDir, projectName);
-    await execAsync(`git -C ${module} fetch --tags`, { cwd: RunOptions.cwd });
+
+    return git.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 git.status(dir);
+
+    return status.trim().length > 0;
+  },
+
+  hasUnpushedCommits: async (dir: string): Promise<boolean> => {
+    await git.fetch(dir);
+
+    const branch = await git.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 git.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 git.currentBranch(dir);
+    if (branch) return;
+
+    await git.fetch(dir);
+    const remoteBranch = await git.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 git.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 git.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 ${module} tag -l`,
+      `git -C ${dir} tag -l`,
       { cwd: RunOptions.cwd },
     );
 

package/src/index.ts

@@ -1 +1,2 @@
 export { SV } from './sv';
+export { versionUtil } from './versionUtil';

package/src/{PkgJSONManager.ts → pkgJSONManager.ts}

@@ -19,39 +19,25 @@ const getJsonPath = async (submoduleName?: string): Promise<TJSONPath> => {
   return jsonPath;
 };
 
-export class PkgJSONManager {
-  private cache: Map<string, any> = new Map();
-
+export const pkgJSONManager = {
   /* Reads package.json in project folder or in submodule */
-  public read = async (submoduleName?: string) => {
+  read: async (submoduleName?: string) => {
     const jsonPath = await getJsonPath(submoduleName);
 
     if (!jsonPath) return null;
 
-    if (this.cache.has(jsonPath)) {
-      return this.cache.get(jsonPath);
-    }
-
     const jsonString = await readFileAsync(jsonPath, 'utf-8');
     const parsed = JSON.parse(jsonString);
 
-    this.cache.set(jsonPath, parsed);
-
     return parsed;
-  };
+  },
 
   /* Writes package.json in project folder or in submodule */
-  public write = async (data: Object, submoduleName?: string) => {
+  write: async (data: Object, submoduleName?: string) => {
     const jsonPath = await getJsonPath(submoduleName);
 
     if (!jsonPath) return;
 
-    this.cache.set(jsonPath, data);
-
     await writeFileAsync(jsonPath, JSON.stringify(data, null, 2));
-  };
-
-  public clearCache (): void {
-    this.cache.clear();
-  }
-}
+  },
+};

package/src/sv.ts

@@ -1,26 +1,22 @@
-import { PkgJSONManager } from "./PkgJSONManager";
-import { Graph } from "./Graph";
+import path from 'path';
+import { pkgJSONManager } from "./pkgJSONManager";
+import { buildGraph } from "./buildGraph";
 import { RunOptions } from "./runOptions";
 import { versionUtil } from "./versionUtil";
-import { git } from "./git";
+import { git, GitError } from "./git";
 
 export class SV {
-  private pkgJSONManager: PkgJSONManager;
-  private graph: Graph;
-
   constructor (
     projectDir: string,
     modulesDir: string = 'addons',
   ) {
     RunOptions.cwd = projectDir;
     RunOptions.modulesDir = modulesDir;
-
-    this.pkgJSONManager = new PkgJSONManager();
-    this.graph = new Graph(this.pkgJSONManager);
   }
 
-  public buildGraph = () => this.graph.build();
+  public buildGraph = buildGraph;
 
+  // eslint-disable-next-line class-methods-use-this
   public install = async (gitUrl: string, parentModule?: string) => {
     const { url, version, name } = git.parseUrl(gitUrl);
 
@@ -28,12 +24,11 @@ export class SV {
       throw new Error('NOT_A_GIT_URL');
     }
 
-    const targetPkg = await this.pkgJSONManager.read(parentModule);
-    let installedPkg = await this.pkgJSONManager.read(name);
+    const targetPkg = await pkgJSONManager.read(parentModule);
+    const installedPkg = await pkgJSONManager.read(name);
 
     if (!installedPkg) {
       await git.addSumbmodule(url);
-      installedPkg = this.pkgJSONManager.read(name);
     }
 
     const versions = await git.listVersions(name);
@@ -49,12 +44,13 @@ export class SV {
     }
 
     targetPkg.sv[url] = requestedVersion ? `^${requestedVersion}` : '*';
-    await this.pkgJSONManager.write(targetPkg, parentModule);
-    await this.graph.build();
+    await pkgJSONManager.write(targetPkg, parentModule);
+    await buildGraph();
   };
 
+  // eslint-disable-next-line class-methods-use-this
   public update = async () => {
-    const graph = await this.graph.build();
+    const graph = await buildGraph();
     if (!graph) return;
     await Promise.all(Object.entries(graph).map(async ([name, data]) => {
       const { version, used } = data;
@@ -65,13 +61,84 @@ export class SV {
     }));
   };
 
+  /*
+   * Устанавливает конкретную версию аддона: checkout на тег + запись constraint'а
+   * в package.json проекта (иначе buildGraph вернёт latest(used)).
+   * constraint по умолчанию — точный пин выбранной версии; при обновлении до
+   * последней имеет смысл передать `^<version>`, чтобы новые версии продолжали приходить.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  public setVersion = async (name: string, version: string, constraint?: string) => {
+    const versions = await git.listVersions(name);
+
+    if (!versions.includes(version)) {
+      throw new Error('REQUESTED_VERSION_NOT_EXISTS');
+    }
+
+    const dir = path.join(RunOptions.modulesDir, name);
+    const dirty = await git.hasChanges(dir);
+
+    /*
+     * checkout с локальными изменениями транзакционен: git переносит их на
+     * новую версию, а если перенести нельзя — отказывается, НЕ трогая дерево.
+     * Значит при ошибке мы гарантированно остаёмся на исходной версии с теми
+     * же изменениями — сообщаем, что перенос нужно сделать вручную.
+     */
+    try {
+      await git.checkout(name, version);
+    } catch (e) {
+      if (dirty) {
+        throw new GitError('GIT_DIRTY_SWITCH_CONFLICT');
+      }
+
+      throw e;
+    }
+
+    const json = await pkgJSONManager.read();
+    if (!json?.sv) return;
+
+    const key = Object.keys(json.sv).find(k => k.endsWith(`${name}.git`));
+    const nextConstraint = constraint || version;
+    if (key && json.sv[key] !== nextConstraint) {
+      json.sv[key] = nextConstraint;
+      await pkgJSONManager.write(json);
+    }
+  };
+
+  /*
+   * Constraint корневого проекта на аддон (ключ в sv ищем по имени, как в remove).
+   */
+  // eslint-disable-next-line class-methods-use-this
+  public getConstraint = async (name: string): Promise<string | null> => {
+    const json = await pkgJSONManager.read();
+    if (!json?.sv) return null;
+
+    const key = Object.keys(json.sv).find(k => k.endsWith(`${name}.git`));
+
+    return key ? json.sv[key] : null;
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public setConstraint = async (name: string, constraint: string): Promise<void> => {
+    const json = await pkgJSONManager.read();
+    if (!json?.sv) return;
+
+    const key = Object.keys(json.sv).find(k => k.endsWith(`${name}.git`));
+
+    if (key && json.sv[key] !== constraint) {
+      json.sv[key] = constraint;
+      await pkgJSONManager.write(json);
+    }
+  };
+
+  // eslint-disable-next-line class-methods-use-this
   public remove = async (submoduleName: string, parentModule?: string) => {
     await git.rm(submoduleName);
-    const json = await this.pkgJSONManager.read(parentModule);
+    const json = await pkgJSONManager.read(parentModule);
 
     if (!json.sv) return;
 
-    const sv = Object.keys(json.sv).reduce((acc, k) => {
+    json.sv = Object.keys(json.sv).reduce((acc, k) => {
       if (k.endsWith(`${submoduleName}.git`)) {
         return acc;
       }
@@ -79,9 +146,141 @@ export class SV {
       return { ...acc, [k]: json.sv[k] };
     }, {});
 
-    json.sv = sv;
+    await pkgJSONManager.write(json, parentModule);
+    await buildGraph();
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public hasChanges = async (module?: string): Promise<boolean> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    /* Сначала дешёвая проверка рабочей копии; если чисто — смотрим,
+     * нет ли незапушенных коммитов (идёт fetch в remote) */
+    if (await git.hasChanges(dir)) return true;
+
+    return git.hasUnpushedCommits(dir);
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public hasUncommittedChanges = async (module?: string): Promise<boolean> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    return git.hasChanges(dir);
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public currentVersion = async (module?: string): Promise<string | null> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    const tags = await git.tagsAtHead(dir);
+
+    return versionUtil.latest(tags) || null;
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public latestVersion = async (module?: string): Promise<string> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    const versions = await git.listTags(dir);
+
+    return versionUtil.latest(versions) || '0.0.0';
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public getRemote = async (module?: string): Promise<string | null> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    return git.getRemote(dir);
+  };
+
+  public isPublished = async (module?: string): Promise<boolean> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    if (!await git.isGitRepo(dir)) return false;
+
+    return !!(await this.getRemote(module));
+  };
+
+  public publish = async (opts: {
+    module?: string,
+    repoUrl?: string,
+    message?: string,
+    bump: 'release' | 'minor' | 'major',
+  }): Promise<string> => {
+    const { module, repoUrl, message, bump } = opts;
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    if (!await this.isPublished(module)) {
+      if (!repoUrl) {
+        throw new GitError('GIT_REPO_URL_REQUIRED');
+      }
+
+      if (!await git.isGitRepo(dir)) {
+        await git.init(dir);
+      }
+
+      await git.addRemote(dir, repoUrl);
+    }
+
+    /* Публикация не последней версии запрещена: HEAD на теге, отличном
+     * от последнего, — обновлять такую базу можно только вручную */
+    const currentTag = await this.currentVersion(module);
+    const latestKnown = await this.latestVersion(module);
+
+    if (currentTag && latestKnown && currentTag !== latestKnown) {
+      throw new GitError('GIT_NOT_LATEST_VERSION');
+    }
+
+    /* Аддоны checkout'нуты на тег: поднимаем ветку до sync/commit,
+     * иначе коммиты и push уйдут в detached HEAD */
+    await git.ensureBranch(dir);
+
+    if (await git.isRemoteAhead(dir)) {
+      await git.pullRebaseAutostash(dir);
+    }
+
+    const dirty = await git.hasChanges(dir);
+    const headTag = await this.currentVersion(module);
+
+    /* Дерево чистое и HEAD уже отмечен версионным тегом:
+     * коммитить и бампить нечего — просто доставляем ветку и тег на remote */
+    if (!dirty && headTag) {
+      await git.push(dir, headTag);
+
+      return headTag;
+    }
+
+    const next = versionUtil.bump(await this.latestVersion(module), bump);
+
+    /* Фиксируем версию и в package.json, чтобы она не расходилась с git-тегом */
+    const pkg = await pkgJSONManager.read(module);
+    if (pkg) {
+      pkg.version = next;
+      await pkgJSONManager.write(pkg, module);
+    }
+
+    /* Перечитываем: запись версии в package.json сама по себе даёт изменения */
+    if (await git.hasChanges(dir)) {
+      await git.commitAll(dir, message || 'Update');
+    }
+
+    await git.addTag(dir, next);
+    await git.push(dir, next);
 
-    await this.pkgJSONManager.write(json, parentModule);
-    await this.graph.build();
+    return next;
   };
 }

package/src/versionUtil.ts

@@ -74,9 +74,22 @@ const latest = (versions: string[]) => (
   })[0] || '')
 );
 
+const bump = (
+  version: string,
+  kind: 'release' | 'minor' | 'major',
+): string => {
+  const [major, minor, patch] = toArray(version);
+
+  if (kind === 'major') return `${major + 1}.0.0`;
+  if (kind === 'minor') return `${major}.${minor + 1}.0`;
+
+  return `${major}.${minor}.${patch + 1}`;
+};
+
 export const versionUtil = {
   compare,
   pick,
   validate,
   latest,
+  bump,
 };