submodule-version 2.3.2 → 3.0.0

package/src/entryStore.ts

@@ -0,0 +1,212 @@
+import { SVError } from './errors';
+import { git } from './git';
+import type {
+  IEntrySource,
+  IOverride,
+  IPackageEntry,
+  TDependencies,
+} from './PubGrub/types';
+
+/*
+ * Оверрайды без parent применяются к корню: add добавляет/меняет
+ * диапазон по url, delete убирает зависимость по имени модуля.
+ */
+const applyRootOverrides = (
+  overrides: IOverride[],
+  rootDeps: TDependencies,
+): TDependencies => {
+  const next = { ...rootDeps };
+
+  overrides.forEach(override => {
+    if (override.add) {
+      const { name } = git.parseUrl(override.add);
+
+      if (!name) {
+        throw new SVError('NOT_A_GIT_URL', { url: override.add });
+      }
+
+      next[override.add] = override.version || '*';
+    }
+
+    if (override.delete) {
+      const key = Object.keys(next)
+        .find(depUrl => git.parseUrl(depUrl).name === override.delete);
+
+      if (!key) {
+        throw new SVError('ADDON_NOT_FOUND', { name: override.delete });
+      }
+
+      delete next[key];
+    }
+  });
+
+  return next;
+};
+
+export class EntryStore implements IEntrySource {
+  private cache = new Map<string, Promise<IPackageEntry>>();
+
+  private urlByName = new Map<string, string>();
+
+  /* Активны только внутри simulate; вне коллбэка оверрайдов не существует */
+  private overrides: IOverride[] | null = null;
+
+  private rememberUrl = (name: string, url: string): void => {
+    const current = this.urlByName.get(name);
+
+    if (current && current !== url) {
+      throw new SVError('ADDON_NOT_FOUND', {
+        name,
+        urls: [current, url],
+      });
+    }
+
+    this.urlByName.set(name, url);
+  };
+
+  private normalizeDependencies = (
+    dependencies: TDependencies = {},
+  ): TDependencies => Object.fromEntries(
+    Object.entries(dependencies).map(([depUrl, constraint]) => {
+      const { name } = git.parseUrl(depUrl);
+
+      if (!name) {
+        throw new SVError('NOT_A_GIT_URL', { url: depUrl });
+      }
+
+      this.rememberUrl(name, depUrl);
+
+      return [name, constraint];
+    }),
+  );
+
+  private load = async (url: string, name: string): Promise<IPackageEntry> => {
+    const fetched = await git.api.fetchVersions(url);
+    const versions: Record<string, TDependencies> = {};
+
+    fetched.forEach(({ version, pkg }) => {
+      versions[version] = this.normalizeDependencies(pkg?.sv || {});
+    });
+
+    return { name, url, versions };
+  };
+
+  private resolveIdentity = (
+    depPath: string,
+  ): { name: string, url: string } => {
+    const parsed = git.parseUrl(depPath);
+
+    if (parsed.name) {
+      this.rememberUrl(parsed.name, parsed.url);
+
+      return { name: parsed.name, url: parsed.url };
+    }
+
+    const url = this.urlByName.get(depPath);
+
+    if (!url) {
+      throw new SVError('ADDON_NOT_FOUND', { name: depPath });
+    }
+
+    return { name: depPath, url };
+  };
+
+  /*
+   * Патчим клон — сырой энтри в кэше остаётся нетронутым, оверрайды
+   * не переживают simulate. add/delete применяются к каждой версии
+   * родителя: будто модуль установлен (или удалён) в любой версии.
+   */
+  private applyOverrides = (entry: IPackageEntry): IPackageEntry => {
+    const related = (this.overrides || [])
+      .filter(override => override.parent === entry.name);
+
+    if (!related.length) return entry;
+
+    const versions = Object.fromEntries(
+      Object.entries(entry.versions).map(([version, deps]) => {
+        const patched = { ...deps };
+
+        related.forEach(override => {
+          if (override.add) {
+            const { name } = git.parseUrl(override.add);
+
+            if (!name) {
+              throw new SVError('NOT_A_GIT_URL', { url: override.add });
+            }
+
+            this.rememberUrl(name, override.add);
+            patched[name] = override.version || '*';
+          }
+
+          if (override.delete) {
+            delete patched[override.delete];
+          }
+        });
+
+        return [version, patched];
+      }),
+    );
+
+    return { ...entry, versions };
+  };
+
+  /*
+   * Загружает только один модуль: сразу все его semver-теги и зависимости
+   * каждого тега. Сами подзависимости здесь не запрашиваются — PubGrub
+   * вызовет fetch(name), только если реально рассмотрит нужную версию.
+   */
+  public fetch = (depPath: string): Promise<IPackageEntry> => {
+    let identity: { name: string, url: string };
+
+    try {
+      identity = this.resolveIdentity(depPath);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+
+    const cached = this.cache.get(identity.url);
+
+    if (cached) {
+      return this.overrides ? cached.then(this.applyOverrides) : cached;
+    }
+
+    const loading = this.load(identity.url, identity.name);
+
+    this.cache.set(identity.url, loading);
+    loading.catch(() => this.cache.delete(identity.url));
+
+    return this.overrides ? loading.then(this.applyOverrides) : loading;
+  };
+
+  /*
+   * Прогон коллбэка с потенциальными изменениями дерева. Оверрайды без
+   * parent превращаются в эффективные rootDeps и уходят аргументом
+   * в коллбэк, parent-оверрайды перезаписывают модули на всех fetch'ах
+   * внутри. После завершения (в т.ч. по ошибке) оверрайды снимаются.
+   */
+  public simulate = async <T>(
+    overrides: IOverride[],
+    rootDeps: TDependencies,
+    cb: (rootDeps: TDependencies) => Promise<T>,
+  ): Promise<T> => {
+    this.overrides = overrides.filter(override => override.parent);
+
+    try {
+      const rootOverrides = overrides.filter(override => !override.parent);
+
+      return await cb(applyRootOverrides(rootOverrides, rootDeps));
+    } finally {
+      this.overrides = null;
+    }
+  };
+
+  public urlOf = (name: string): string | undefined => this.urlByName.get(name);
+
+  /* Изоляция тестов и явное обновление remote-каталога. */
+  public clear = (): void => {
+    this.cache.clear();
+    this.urlByName.clear();
+  };
+}
+
+export const entryStore = new EntryStore();

package/src/errors.ts

@@ -0,0 +1,39 @@
+export const ERR = {
+  NOT_A_NPM: 'NOT_A_NPM',
+  NOT_A_GIT_REPO: 'NOT_A_GIT_REPO',
+  NOT_A_GIT_URL: 'NOT_A_GIT_URL',
+  NOT_INITIALIZED: 'NOT_INITIALIZED',
+  NOT_IMPLEMENTED: 'NOT_IMPLEMENTED',
+  PATH_NOT_FOUND: 'PATH_NOT_FOUND',
+  ADDON_NOT_FOUND: 'ADDON_NOT_FOUND',
+  REQUESTED_VERSION_NOT_EXISTS: 'REQUESTED_VERSION_NOT_EXISTS',
+  VERSION_CONFLICT: 'VERSION_CONFLICT',
+  CIRCULAR_DEPENDENCY: 'CIRCULAR_DEPENDENCY',
+  UNKNOWN_VERSION: 'UNKNOWN_VERSION',
+  GIT_DIRTY_SWITCH_CONFLICT: 'GIT_DIRTY_SWITCH_CONFLICT',
+} as const;
+
+export type TSVErrorCode = keyof typeof ERR;
+
+export type TSVErrorDetails = {
+  /* Путь от корня проекта до блокирующего аддона (имена узлов) */
+  chain?: string[];
+  requestedVersion?: string;
+  installedVersion?: string;
+  parents?: Record<string, string>;
+  versions?: string[];
+  [k: string]: unknown;
+};
+
+/*
+ * Единственный тип ошибки, который уходит наружу из методов SV.
+ * GitError остаётся во внутреннем git-слое.
+ */
+export class SVError extends Error {
+  constructor (
+    public error: TSVErrorCode,
+    public details: TSVErrorDetails = {},
+  ) {
+    super(error);
+  }
+}

package/src/git/api/GithubError.ts

@@ -0,0 +1,5 @@
+export class GithubError extends Error {
+  constructor (type: string, public details: Record<string, any> = {}) {
+    super(type);
+  }
+}

package/src/git/api/api.ts

@@ -0,0 +1,180 @@
+import { versionUtil } from '../../versionUtil';
+import { GithubError } from './GithubError';
+
+/*
+ * GitHub GraphQL API без внешних зависимостей (глобальный fetch, Node 18+).
+ * Токен обязателен (GraphQL не работает анонимно): из JS API
+ * (git.api.setToken) или GITHUB_TOKEN из env.
+ */
+const ENDPOINT = 'https://api.github.com/graphql';
+
+/*
+ * owner/repo из git-url'а: https/ssh (github.com:owner/repo.git)
+ * и github:-shorthand (github:owner/repo).
+ */
+const parseSlug = (url: string): string | null => {
+  const shorthand = /^github:(?<slug>[\w.-]+\/[\w.-]+)$/.exec(url);
+
+  if (shorthand?.groups) return shorthand.groups.slug;
+
+  const match = /github\.com[/:](?<slug>[\w.-]+\/[\w.-]+?)(\.git)?$/.exec(url);
+
+  return match?.groups?.slug || null;
+};
+
+/* Токен, переданный через JS API (SV); без него — GITHUB_TOKEN из env */
+let apiToken: string | undefined;
+
+interface IGqlError {
+  type?: string;
+  message: string;
+}
+
+const gql = async (
+  query: string,
+  variables: Record<string, unknown>,
+): Promise<any> => {
+  const token = apiToken || process.env.GITHUB_TOKEN;
+
+  if (!token) {
+    throw new GithubError('GITHUB_TOKEN_REQUIRED', {});
+  }
+
+  const res = await fetch(ENDPOINT, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/vnd.github+json',
+      'User-Agent': 'submodule-version',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+
+  if (!res.ok) {
+    throw new GithubError('GITHUB_API_FAILED', { status: res.status });
+  }
+
+  const body = await res.json() as {
+    data?: any,
+    errors?: IGqlError[],
+  };
+
+  if (body.errors?.length) {
+    /* NOT_FOUND = репо не существует или нет доступа (как 404 в REST) */
+    const notFound = body.errors.some(e => e.type === 'NOT_FOUND');
+
+    throw new GithubError('GITHUB_API_FAILED', {
+      status: notFound ? 404 : 400,
+      errors: body.errors.map(e => e.message),
+    });
+  }
+
+  return body.data;
+};
+
+const TAGS_QUERY = `
+  query ($owner: String!, $name: String!, $cursor: String) {
+    repository(owner: $owner, name: $name) {
+      refs(refPrefix: "refs/tags/", first: 100, after: $cursor) {
+        nodes { name }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+`;
+
+/* Все semver-теги репозитория (пагинация по 100) */
+const listTags = async (slug: string): Promise<string[]> => {
+  const [owner, name] = slug.split('/');
+  const tags: string[] = [];
+  let cursor: string | null = null;
+
+  do {
+    const data = await gql(TAGS_QUERY, { owner, name, cursor });
+
+    if (!data.repository) {
+      throw new GithubError('GITHUB_API_FAILED', { status: 404, url: slug });
+    }
+
+    const { nodes, pageInfo } = data.repository.refs;
+
+    nodes.forEach((node: { name: string }) => {
+      if (versionUtil.validate(node.name)) tags.push(node.name);
+    });
+
+    cursor = pageInfo.hasNextPage ? pageInfo.endCursor : null;
+  } while (cursor);
+
+  return tags;
+};
+
+/*
+ * package.json каждого тега одним запросом: alias v<i> на
+ * object(expression: "<tag>:package.json"). Теги отфильтрованы по semver,
+ * так что инъекция в expression исключена. Нет файла — null.
+ */
+const listPackages = async (
+  slug: string,
+  tags: string[],
+): Promise<Array<any | null>> => {
+  if (!tags.length) return [];
+
+  const [owner, name] = slug.split('/');
+
+  const fields = tags.map((tag, i) => (
+    // eslint-disable-next-line max-len
+    `v${i}: object(expression: ${JSON.stringify(`${tag}:package.json`)}) { ... on Blob { text } }`
+  )).join('\n');
+
+  const query = `
+    query ($owner: String!, $name: String!) {
+      repository(owner: $owner, name: $name) {
+        ${fields}
+      }
+    }
+  `;
+
+  const data = await gql(query, { owner, name });
+
+  return tags.map((tag, i) => {
+    const text = data.repository?.[`v${i}`]?.text;
+
+    if (!text) return null;
+
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  });
+};
+
+export interface IGithubVersion {
+  version: string;
+  /* package.json на теге; нет файла или битый JSON — null */
+  pkg: any | null;
+}
+
+export const api = {
+  /* Токен из JS API; без него (и при undefined) работает env-переменная */
+  setToken: (token?: string): void => {
+    apiToken = token;
+  },
+
+  /*
+   * Теги репозитория + package.json каждого тега: 1 запрос на страницу
+   * тегов + 1 батч-запрос на deps всех тегов.
+   */
+  fetchVersions: async (url: string): Promise<IGithubVersion[]> => {
+    const slug = parseSlug(url);
+
+    if (!slug) {
+      throw new GithubError('GITHUB_NOT_A_REPO_URL', { url });
+    }
+
+    const tags = await listTags(slug);
+    const pkgs = await listPackages(slug, tags);
+
+    return tags.map((version, i) => ({ version, pkg: pkgs[i] }));
+  },
+};

package/src/git/api/index.ts

@@ -0,0 +1,3 @@
+export { api } from './api';
+export type { IGithubVersion } from './api';
+export { GithubError } from './GithubError';