index.ts

import crypto from 'crypto';
import { logger } from '../../logger';
import * as globalCache from '../../util/cache/global';
import { Http } from '../../util/http';
import { GithubHttp } from '../../util/http/github';
import { GetReleasesConfig, ReleaseResult } from '../common';

export const id = 'pod';

export const defaultRegistryUrls = ['https://cdn.cocoapods.org'];

const cacheNamespace = `datasource-${id}`;
const cacheMinutes = 30;

const githubHttp = new GithubHttp();
const http = new Http(id);

function shardParts(lookupName: string): string[] {
  return crypto
    .createHash('md5')
    .update(lookupName)
    .digest('hex')
    .slice(0, 3)
    .split('');
}

function releasesGithubUrl(
  lookupName: string,
  opts: { account: string; repo: string; useShard: boolean }
): string {
  const { useShard, account, repo } = opts;
  const prefix = 'https://api.github.com/repos';
  const shard = shardParts(lookupName).join('/');
  const suffix = useShard ? `${shard}/${lookupName}` : lookupName;
  return `${prefix}/${account}/${repo}/contents/Specs/${suffix}`;
}

function handleError(lookupName: string, err: Error): void {
  const errorData = { lookupName, err };

  if (
    err.statusCode === 429 ||
    (err.statusCode >= 500 && err.statusCode < 600)
  ) {
    logger.warn({ lookupName, err }, `CocoaPods registry failure`);
    throw new Error('registry-failure');
  }

  if (err.statusCode === 401) {
    logger.debug(errorData, 'Authorization error');
  } else if (err.statusCode === 404) {
    logger.debug(errorData, 'Package lookup error');
  } else {
    logger.warn(errorData, 'CocoaPods lookup failure: Unknown error');
  }
}

async function requestCDN(
  url: string,
  lookupName: string
): Promise<string | null> {
  try {
    const resp = await http.get(url);
    if (resp && resp.body) {
      return resp.body;
    }
  } catch (err) {
    handleError(lookupName, err);
  }

  return null;
}

async function requestGithub<T = unknown>(
  url: string,
  lookupName: string
): Promise<T | null> {
  try {
    const resp = await githubHttp.getJson<T>(url);
    if (resp && resp.body) {
      return resp.body;
    }
  } catch (err) {
    handleError(lookupName, err);
  }

  return null;
}

const githubRegex = /^https:\/\/github\.com\/(?<account>[^/]+)\/(?<repo>[^/]+?)(\.git|\/.*)?$/;

async function getReleasesFromGithub(
  lookupName: string,
  registryUrl: string,
  useShard = false
): Promise<ReleaseResult | null> {
  const match = githubRegex.exec(registryUrl);
  const { account, repo } = (match && match.groups) || {};
  const opts = { account, repo, useShard };
  const url = releasesGithubUrl(lookupName, opts);
  const resp = await requestGithub<{ name: string }[]>(url, lookupName);
  if (resp) {
    const releases = resp.map(({ name }) => ({ version: name }));
    return { releases };
  }

  if (!useShard) {
    return getReleasesFromGithub(lookupName, registryUrl, true);
  }

  return null;
}

function releasesCDNUrl(lookupName: string, registryUrl: string): string {
  const shard = shardParts(lookupName).join('_');
  return `${registryUrl}/all_pods_versions_${shard}.txt`;
}

async function getReleasesFromCDN(
  lookupName: string,
  registryUrl: string
): Promise<ReleaseResult | null> {
  const url = releasesCDNUrl(lookupName, registryUrl);
  const resp = await requestCDN(url, lookupName);
  if (resp) {
    const lines = resp.split('\n');
    for (let idx = 0; idx < lines.length; idx += 1) {
      const line = lines[idx];
      const [name, ...versions] = line.split('/');
      if (name === lookupName.replace(/\/.*$/, '')) {
        const releases = versions.map((version) => ({ version }));
        return { releases };
      }
    }
  }
  return null;
}

function isDefaultRepo(url: string): boolean {
  const match = githubRegex.exec(url);
  if (match) {
    const { account, repo } = match.groups || {};
    return (
      account.toLowerCase() === 'cocoapods' && repo.toLowerCase() === 'specs'
    ); // https://github.com/CocoaPods/Specs.git
  }
  return false;
}

export async function getReleases({
  lookupName,
  registryUrls,
}: GetReleasesConfig): Promise<ReleaseResult | null> {
  const podName = lookupName.replace(/\/.*$/, '');

  const cachedResult = await globalCache.get<ReleaseResult>(
    cacheNamespace,
    podName
  );
  /* istanbul ignore next line */
  if (cachedResult) {
    logger.debug(`CocoaPods: Return cached result for ${podName}`);
    return cachedResult;
  }

  let result: ReleaseResult | null = null;
  for (let idx = 0; !result && idx < registryUrls.length; idx += 1) {
    let registryUrl = registryUrls[idx].replace(/\/+$/, '');

    // In order to not abuse github API limits, query CDN instead
    if (isDefaultRepo(registryUrl)) {
      [registryUrl] = defaultRegistryUrls;
    }

    if (githubRegex.exec(registryUrl)) {
      result = await getReleasesFromGithub(podName, registryUrl);
    } else {
      result = await getReleasesFromCDN(podName, registryUrl);
    }
  }

  if (result) {
    await globalCache.set(cacheNamespace, podName, result, cacheMinutes);
  }

  return result;
}