submodule-version 2.3.2 → 3.0.0

package/src/sv.ts

@@ -1,153 +1,333 @@
 import path from 'path';
-import { pkgJSONManager } from "./pkgJSONManager";
-import { buildGraph } from "./buildGraph";
-import { RunOptions } from "./runOptions";
-import { versionUtil } from "./versionUtil";
-import { git, GitError } from "./git";
+import { readFile } from 'fs/promises';
+import { pkgJSONManager } from './pkgJSONManager';
+import {
+  PubGrub,
+  IOverride,
+  TDependencies,
+  TPubGrubResult,
+} from './PubGrub';
+import { EntryStore } from './entryStore';
+import { RunOptions } from './runOptions';
+import { versionUtil } from './versionUtil';
+import { git, GitError } from './git';
+import { SVError } from './errors';
+
+/*
+ * Правка package.json родителя (внутри его сабмодуля): parent-level
+ * мутации обязаны пережить публикацию родителя, поэтому диапазон
+ * пишется в его поле sv.
+ */
+const updateModuleJson = async (
+  parent: string,
+  override: IOverride,
+): Promise<void> => {
+  const parentJson = await pkgJSONManager.read(parent);
+
+  if (!parentJson) throw new SVError('ADDON_NOT_FOUND', { name: parent });
+
+  const sv = { ...((parentJson.sv || {}) as TDependencies) };
+
+  if (override.add) sv[override.add] = override.version || '*';
+
+  if (override.delete) {
+    const key = Object.keys(sv)
+      .find(depUrl => git.parseUrl(depUrl).name === override.delete);
+
+    if (!key) throw new SVError('ADDON_NOT_FOUND', { name: override.delete });
+
+    delete sv[key];
+  }
+
+  parentJson.sv = sv;
+  await pkgJSONManager.write(parentJson, parent);
+};
+
+/*
+ * modulesDir должен быть npm-workspace, иначе сабмодули не попадут
+ * в node_modules. Поддерживаем оба формата: workspaces: [] и
+ * workspaces: { packages: [] }. Возвращает true, если json изменён.
+ */
+const ensureWorkspaces = (baseJson: any): boolean => {
+  const entry = `${RunOptions.modulesDir}/*`;
+
+  if (Array.isArray(baseJson.workspaces)) {
+    if (baseJson.workspaces.includes(entry)) return false;
+
+    baseJson.workspaces.push(entry);
+
+    return true;
+  }
+
+  const packages = baseJson.workspaces?.packages;
+
+  if (Array.isArray(packages)) {
+    if (packages.includes(entry)) return false;
+
+    packages.push(entry);
+
+    return true;
+  }
+
+  baseJson.workspaces = [entry];
+
+  return true;
+};
+
+const MODULES_DIR_FIELD = 'sv-dir';
+const DEFAULT_MODULES_DIR = 'modules';
+
+/*
+ * Уже добавленные сабмодули — источник правды о директории:
+ * .gitmodules с единым родителем у всех path (addons/X, addons/Y → addons).
+ */
+const deriveModulesDir = async (): Promise<string | null> => {
+  try {
+    const content = await readFile(
+      path.join(RunOptions.cwd, '.gitmodules'),
+      'utf-8',
+    );
+
+    const dirs = new Set(
+      [...content.matchAll(/^\s*path\s*=\s*(.+)$/gm)]
+        .map(match => match[1].trim().split('/')[0]),
+    );
+
+    return dirs.size === 1 ? [...dirs][0] : null;
+  } catch {
+    return null;
+  }
+};
 
 export class SV {
+  private resolution: TPubGrubResult | null = null;
+
+  private store = new EntryStore();
+
+  private explicitModulesDir?: string;
+
   constructor (
     projectDir: string,
-    modulesDir: string = 'addons',
+    modulesDir?: string,
+    options: { githubToken?: string } = {},
   ) {
     RunOptions.cwd = projectDir;
-    RunOptions.modulesDir = modulesDir;
+    RunOptions.modulesDir = modulesDir || DEFAULT_MODULES_DIR;
+    this.explicitModulesDir = modulesDir;
+    git.api.setToken(options.githubToken);
   }
 
-  public buildGraph = buildGraph;
+  /*
+   * Директория модулей: явно переданная (CLI/JS) → записанная в
+   * package.json#sv-dir → выведенная из .gitmodules → 'modules'.
+   * Эффективная записывается в sv-dir. Возвращает true, если json изменён.
+   */
+  private syncModulesDir = async (baseJson: any): Promise<boolean> => {
+    const recorded = baseJson[MODULES_DIR_FIELD] as string | undefined;
 
-  // eslint-disable-next-line class-methods-use-this
-  public install = async (gitUrl: string, parentModule?: string) => {
-    const { url, version, name } = git.parseUrl(gitUrl);
+    if (!this.explicitModulesDir) {
+      if (recorded) {
+        RunOptions.modulesDir = recorded;
 
-    if (!name) {
-      throw new Error('NOT_A_GIT_URL');
-    }
+        return false;
+      }
 
-    const targetPkg = await pkgJSONManager.read(parentModule);
-    const installedPkg = await pkgJSONManager.read(name);
+      const derived = await deriveModulesDir();
 
-    if (!installedPkg) {
-      await git.addSumbmodule(url);
+      if (derived) RunOptions.modulesDir = derived;
     }
 
-    const versions = await git.listVersions(name);
-    const latestVersion = versionUtil.latest(versions);
-    const requestedVersion = version || latestVersion;
+    if (recorded === RunOptions.modulesDir) return false;
 
-    if (!versions.includes(requestedVersion) && versions.length) {
-      throw new Error('REQUESTED_VERSION_NOT_EXISTS');
-    }
-
-    if (!targetPkg.sv) {
-      targetPkg.sv = {};
-    }
+    baseJson[MODULES_DIR_FIELD] = RunOptions.modulesDir;
 
-    targetPkg.sv[url] = requestedVersion ? `^${requestedVersion}` : '*';
-    await pkgJSONManager.write(targetPkg, parentModule);
-    await buildGraph();
+    return true;
   };
 
-  // eslint-disable-next-line class-methods-use-this
-  public update = async () => {
-    const graph = await buildGraph();
-    if (!graph) return;
-    await Promise.all(Object.entries(graph).map(async ([name, data]) => {
-      const { version, used } = data;
-      const latestVersion = versionUtil.latest(used);
-      if (latestVersion !== version) {
-        await git.checkout(name, latestVersion);
+  private resolveDeps = (
+    rootDeps: TDependencies,
+  ): Promise<TPubGrubResult> => new PubGrub(this.store).resolve(rootDeps);
+
+  /*
+   * Синк рабочей копии с резолвом: недостающие сабмодули добавляются,
+   * версии переключаются, исчезнувшие из резолва модули удаляются.
+   */
+  private syncModules = async (resolution: TPubGrubResult): Promise<void> => {
+    const previous = this.resolution || {};
+
+    await Promise.all(Object.entries(resolution).map(async ([name, entry]) => {
+      const dir = path.join(RunOptions.modulesDir, name);
+
+      if (!await git.local.isGitRepo(dir)) {
+        await git.local.addSubmodule(entry.url);
+      }
+
+      if (await git.local.currentVersion(name) !== entry.version) {
+        await git.local.checkout(name, entry.version);
       }
     }));
+
+    const removed = Object.keys(previous).filter(name => !resolution[name]);
+
+    await Promise.all(removed.map(name => git.local.rm(name)));
   };
 
   /*
-   * Устанавливает конкретную версию аддона: checkout на тег + запись constraint'а
-   * в package.json проекта (иначе buildGraph вернёт latest(used)).
-   * constraint по умолчанию — точный пин выбранной версии; при обновлении до
-   * последней имеет смысл передать `^<version>`, чтобы новые версии продолжали приходить.
+   * Общий путь мутаций: проверка через resolve внутри simulate, и только
+   * если ошибки нет — установка/переключение модулей и правка package.json
+   * (корня или родителя).
    */
-  // 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');
+  private apply = async (
+    baseJson: any,
+    override: IOverride,
+    parent?: string,
+  ): Promise<void> => {
+    const dirChanged = await this.syncModulesDir(baseJson);
+    const rootDeps = (baseJson.sv || {}) as TDependencies;
+    let nextRootDeps = rootDeps;
+
+    const resolution = await this.store.simulate(
+      [override],
+      rootDeps,
+      deps => {
+        nextRootDeps = deps;
+
+        return this.resolveDeps(deps);
+      },
+    );
+
+    await this.syncModules(resolution);
+
+    if (parent) {
+      await updateModuleJson(parent, override);
+
+      if (dirChanged) await pkgJSONManager.write(baseJson);
+    } else {
+      baseJson.sv = nextRootDeps;
+      await pkgJSONManager.write(baseJson);
     }
 
-    const dir = path.join(RunOptions.modulesDir, name);
-    const dirty = await git.hasChanges(dir);
+    this.resolution = resolution;
+  };
 
-    /*
-     * checkout с локальными изменениями транзакционен: git переносит их на
-     * новую версию, а если перенести нельзя — отказывается, НЕ трогая дерево.
-     * Значит при ошибке мы гарантированно остаёмся на исходной версии с теми
-     * же изменениями — сообщаем, что перенос нужно сделать вручную.
-     */
-    try {
-      await git.checkout(name, version);
-    } catch (e) {
-      if (dirty) {
-        throw new GitError('GIT_DIRTY_SWITCH_CONFLICT');
-      }
+  public init = async (): Promise<void> => {
+    const baseJson = await pkgJSONManager.read();
+
+    if (!baseJson) throw new SVError('NOT_A_NPM');
 
-      throw e;
+    if (!await git.local.isGitRepo(RunOptions.cwd)) {
+      throw new SVError('NOT_A_GIT_REPO');
     }
 
-    const json = await pkgJSONManager.read();
-    if (!json?.sv) return;
+    const dirChanged = await this.syncModulesDir(baseJson);
 
-    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);
+    if (ensureWorkspaces(baseJson) || dirChanged) {
+      await pkgJSONManager.write(baseJson);
     }
+
+    const rootDeps = (baseJson.sv || {}) as TDependencies;
+    const resolution = await this.resolveDeps(rootDeps);
+
+    await this.syncModules(resolution);
+
+    this.resolution = resolution;
+  };
+
+  public getResolution = (): TPubGrubResult => {
+    if (!this.resolution) throw new SVError('NOT_INITIALIZED');
+
+    return this.resolution;
   };
 
   /*
-   * Constraint корневого проекта на аддон (ключ в sv ищем по имени, как в remove).
+   * Установка/смена версии модуля. Первый аргумент — url репозитория
+   * или имя уже установленного модуля. Без parentName — в корне проекта,
+   * без version — максимально возможная ('*'). Второй аргумент —
+   * версия, если это валидный semver-диапазон, иначе имя родителя.
    */
-  // 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;
+  public put = async (
+    url: string,
+    versionOrParent?: string,
+    parentName?: string,
+  ): Promise<void> => {
+    const isVersion = !!versionOrParent
+      && versionUtil.validate(versionOrParent, true);
 
-    const key = Object.keys(json.sv).find(k => k.endsWith(`${name}.git`));
+    const range = (isVersion ? versionOrParent : undefined) || '*';
+    const parent = (isVersion ? parentName : versionOrParent) || undefined;
+    const baseJson = await pkgJSONManager.read();
 
-    return key ? json.sv[key] : null;
-  };
+    if (!baseJson) throw new SVError('NOT_A_NPM');
 
-  // 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;
+    /*
+     * Вместо url можно передать имя уже установленного модуля —
+     * url берём из текущего резолва.
+     */
+    let moduleUrl = url;
+
+    if (!git.parseUrl(url).name) {
+      const existing = this.getResolution()[url];
+
+      if (!existing) throw new SVError('NOT_A_GIT_URL', { url });
 
-    const key = Object.keys(json.sv).find(k => k.endsWith(`${name}.git`));
+      moduleUrl = existing.url;
+    }
 
-    if (key && json.sv[key] !== constraint) {
-      json.sv[key] = constraint;
-      await pkgJSONManager.write(json);
+    if (parent && !this.getResolution()[parent]) {
+      throw new SVError('ADDON_NOT_FOUND', { name: parent });
     }
+
+    await this.apply(
+      baseJson,
+      { parent, add: moduleUrl, version: range },
+      parent,
+    );
   };
 
-  // eslint-disable-next-line class-methods-use-this
-  public remove = async (submoduleName: string, parentModule?: string) => {
-    await git.rm(submoduleName);
-    const json = await pkgJSONManager.read(parentModule);
+  /* Удаление модуля из родителя (без parentName — из корня проекта). */
+  public delete = async (name: string, parentName?: string): Promise<void> => {
+    const baseJson = await pkgJSONManager.read();
 
-    if (!json.sv) return;
+    if (!baseJson) throw new SVError('NOT_A_NPM');
+
+    if (parentName) {
+      const parentEntry = this.getResolution()[parentName];
+
+      if (!parentEntry) {
+        throw new SVError('ADDON_NOT_FOUND', { name: parentName });
+      }
 
-    json.sv = Object.keys(json.sv).reduce((acc, k) => {
-      if (k.endsWith(`${submoduleName}.git`)) {
-        return acc;
+      if (!(name in parentEntry.dependencies)) {
+        throw new SVError('ADDON_NOT_FOUND', { name });
       }
+    }
+
+    await this.apply(
+      baseJson,
+      { parent: parentName, delete: name },
+      parentName,
+    );
+  };
+
+  public listVersions = (
+    name?: string,
+  ): Record<string, string[]> | string[] => {
+    const resolution = this.getResolution();
+
+    if (name) {
+      const entry = resolution[name];
 
-      return { ...acc, [k]: json.sv[k] };
-    }, {});
+      if (!entry) throw new SVError('ADDON_NOT_FOUND', { name });
 
-    await pkgJSONManager.write(json, parentModule);
-    await buildGraph();
+      return versionUtil.sort(Object.keys(entry.versions));
+    }
+
+    return Object.fromEntries(
+      Object.entries(resolution).map(([entryName, entry]) => [
+        entryName,
+        versionUtil.sort(Object.keys(entry.versions)),
+      ]),
+    );
   };
 
   // eslint-disable-next-line class-methods-use-this
@@ -156,11 +336,9 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    /* Сначала дешёвая проверка рабочей копии; если чисто — смотрим,
-     * нет ли незапушенных коммитов (идёт fetch в remote) */
-    if (await git.hasChanges(dir)) return true;
+    if (await git.local.hasChanges(dir)) return true;
 
-    return git.hasUnpushedCommits(dir);
+    return git.local.hasUnpushedCommits(dir);
   };
 
   // eslint-disable-next-line class-methods-use-this
@@ -169,7 +347,7 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    return git.hasChanges(dir);
+    return git.local.hasChanges(dir);
   };
 
   // eslint-disable-next-line class-methods-use-this
@@ -178,7 +356,7 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    const tags = await git.tagsAtHead(dir);
+    const tags = await git.local.tagsAtHead(dir);
 
     return versionUtil.latest(tags) || null;
   };
@@ -189,7 +367,7 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    const versions = await git.listTags(dir);
+    const versions = await git.local.listTags(dir);
 
     return versionUtil.latest(versions) || '0.0.0';
   };
@@ -200,7 +378,7 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    return git.getRemote(dir);
+    return git.local.getRemote(dir);
   };
 
   public isPublished = async (module?: string): Promise<boolean> => {
@@ -208,11 +386,31 @@ export class SV {
       ? path.join(RunOptions.modulesDir, module)
       : RunOptions.cwd;
 
-    if (!await git.isGitRepo(dir)) return false;
+    if (!await git.local.isGitRepo(dir)) return false;
 
     return !!(await this.getRemote(module));
   };
 
+  // eslint-disable-next-line class-methods-use-this
+  public isRemoteAhead = async (module?: string): Promise<boolean> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    if (!await git.local.isGitRepo(dir)) return false;
+
+    return git.local.isRemoteAhead(dir);
+  };
+
+  // eslint-disable-next-line class-methods-use-this
+  public pullRebaseAutostash = async (module?: string): Promise<void> => {
+    const dir = module
+      ? path.join(RunOptions.modulesDir, module)
+      : RunOptions.cwd;
+
+    return git.local.pullRebaseAutostash(dir);
+  };
+
   public publish = async (opts: {
     module?: string,
     repoUrl?: string,
@@ -220,24 +418,19 @@ export class SV {
     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 (!repoUrl) throw new GitError('GIT_REPO_URL_REQUIRED');
 
-      if (!await git.isGitRepo(dir)) {
-        await git.init(dir);
-      }
+      if (!await git.local.isGitRepo(dir)) await git.local.init(dir);
 
-      await git.addRemote(dir, repoUrl);
+      await git.local.addRemote(dir, repoUrl);
     }
 
-    /* Публикация не последней версии запрещена: HEAD на теге, отличном
-     * от последнего, — обновлять такую базу можно только вручную */
     const currentTag = await this.currentVersion(module);
     const latestKnown = await this.latestVersion(module);
 
@@ -245,41 +438,35 @@ export class SV {
       throw new GitError('GIT_NOT_LATEST_VERSION');
     }
 
-    /* Аддоны checkout'нуты на тег: поднимаем ветку до sync/commit,
-     * иначе коммиты и push уйдут в detached HEAD */
-    await git.ensureBranch(dir);
+    await git.local.ensureBranch(dir);
 
-    if (await git.isRemoteAhead(dir)) {
-      await git.pullRebaseAutostash(dir);
+    if (await git.local.isRemoteAhead(dir)) {
+      await git.local.pullRebaseAutostash(dir);
     }
 
-    const dirty = await git.hasChanges(dir);
+    const dirty = await git.local.hasChanges(dir);
     const headTag = await this.currentVersion(module);
 
-    /* Дерево чистое и HEAD уже отмечен версионным тегом:
-     * коммитить и бампить нечего — просто доставляем ветку и тег на remote */
     if (!dirty && headTag) {
-      await git.push(dir, headTag);
+      await git.local.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');
+    if (await git.local.hasChanges(dir)) {
+      await git.local.commitAll(dir, message || 'Update');
     }
 
-    await git.addTag(dir, next);
-    await git.push(dir, next);
+    await git.local.addTag(dir, next);
+    await git.local.push(dir, next);
 
     return next;
   };

package/src/versionUtil/__tests__/versionUtil.test.ts

@@ -0,0 +1,62 @@
+import { versionUtil } from '../versionUtil';
+
+describe('versionUtil: SemVer primitives', () => {
+  it('validates exact versions and ranges separately', () => {
+    expect(versionUtil.validate('1.2.3')).toBe(true);
+    expect(versionUtil.validate('1.2.3-beta.1')).toBe(true);
+    expect(versionUtil.validate('v1.2.3')).toBe(false);
+    expect(versionUtil.validate('^1.2.3')).toBe(false);
+    expect(versionUtil.validate('^1.2.3', true)).toBe(true);
+    expect(versionUtil.validate('~1.2.3', true)).toBe(true);
+    expect(versionUtil.validate('*', true)).toBe(true);
+    expect(versionUtil.validate('', true)).toBe(false);
+    expect(versionUtil.validate('not-a-range', true)).toBe(false);
+  });
+
+  it('uses standard caret semantics for zero versions', () => {
+    expect(versionUtil.satisfies('1.9.0', '^1.2.3')).toBe(true);
+    expect(versionUtil.satisfies('2.0.0', '^1.2.3')).toBe(false);
+    expect(versionUtil.satisfies('0.2.9', '^0.2.3')).toBe(true);
+    expect(versionUtil.satisfies('0.3.0', '^0.2.3')).toBe(false);
+    expect(versionUtil.satisfies('0.0.3', '^0.0.3')).toBe(true);
+    expect(versionUtil.satisfies('0.0.4', '^0.0.3')).toBe(false);
+  });
+
+  it('selects the highest version satisfying every constraint', () => {
+    const versions = ['2.0.0', '1.4.2', '1.3.2', 'broken'];
+
+    expect(versionUtil.sort(versions)).toEqual(['2.0.0', '1.4.2', '1.3.2']);
+    expect(versionUtil.select(versions, ['^1.3.2', '^1.4.0']))
+      .toEqual(['1.4.2']);
+    expect(versionUtil.latest(versions, ['^1.0.0'])).toBe('1.4.2');
+    expect(versionUtil.compare('1.2.0', '1.1.9')).toBeGreaterThan(0);
+  });
+});
+
+describe('versionUtil: finite sets used by PubGrub', () => {
+  const one = ['1.0.0', '1.2.0'];
+  const two = ['1.2.0', '2.0.0'];
+
+  it('intersects, joins and subtracts version sets', () => {
+    expect(versionUtil.intersection(one, two)).toEqual(['1.2.0']);
+    expect(versionUtil.union(one, two)).toEqual(['2.0.0', '1.2.0', '1.0.0']);
+    expect(versionUtil.difference(one, two)).toEqual(['1.0.0']);
+  });
+
+  it('checks intersection and subset relations', () => {
+    expect(versionUtil.intersects(one, two)).toBe(true);
+    expect(versionUtil.intersects(['1.0.0'], ['2.0.0'])).toBe(false);
+    expect(versionUtil.isSubset(['1.2.0'], one)).toBe(true);
+    expect(versionUtil.isSubset(one, ['1.2.0'])).toBe(false);
+  });
+});
+
+describe('versionUtil.bump', () => {
+  it.each([
+    ['release', '1.2.4'],
+    ['minor', '1.3.0'],
+    ['major', '2.0.0'],
+  ] as const)('bumps %s', (kind, expected) => {
+    expect(versionUtil.bump('1.2.3', kind)).toBe(expected);
+  });
+});

package/src/versionUtil/index.ts

@@ -0,0 +1,2 @@
+export { versionUtil } from './versionUtil';
+export type { TVersionConstraint } from './versionUtil';