packagistFetch.js

// Copyright (c) Microsoft Corporation and others. Licensed under the MIT license.
// SPDX-License-Identifier: MIT

const AbstractFetch = require('./abstractFetch')
const requestRetry = require('requestretry').defaults({ maxAttempts: 3, fullResponse: true })
const fs = require('fs')
const { get } = require('lodash')
const { getStream } = require('../../lib/fetch')
const { promisify } = require('util')
const readdir = promisify(fs.readdir)
const FetchResult = require('../../lib/fetchResult')

const providerMap = {
  packagist: 'https://repo.packagist.org/'
}

class PackagistFetch extends AbstractFetch {
  canHandle(request) {
    const spec = this.toSpec(request)
    return spec && spec.provider === 'packagist'
  }

  async handle(request) {
    const spec = this.toSpec(request)
    const registryData = await this._getRegistryData(spec)
    if (!registryData || !registryData.manifest) return this.markSkip(request)
    super.handle(request)
    const file = this.createTempFile(request)
    await this._getPackage(request, registryData, file.name)
    const dir = this.createTempDir(request)
    await this.decompress(file.name, dir.name)
    const hashes = await this.computeHashes(file.name)

    const fetchResult = new FetchResult(request.url)
    fetchResult.document = this._createDocument(dir, registryData, hashes)
    fetchResult.document.dirRoot = await this._getDirRoot(dir.name)
    request.fetchResult = fetchResult.adoptCleanup(dir, request)
    return request
  }

  async _getRegistryData(spec) {
    const baseUrl = providerMap.packagist
    const { body, statusCode } = await requestRetry.get(`${baseUrl}p2/${spec.namespace}/${spec.name}.json`, {
      json: true
    })
    if (statusCode !== 200 || !body) return null
    const registryData = body

    // Get the array of versions for this package
    const packageVersions = registryData.packages[`${spec.namespace}/${spec.name}`]
    registryData.manifest = this._extractManifest(packageVersions, spec)
    if (!registryData.manifest) return null

    registryData.releaseDate = get(registryData, 'manifest.time')
    delete registryData['packages']
    return registryData
  }

  _extractManifest(packageVersions, spec) {
    if (!packageVersions || !Array.isArray(packageVersions)) return null

    // Find the specific version in the array - handle both 'v1.0.0' and '1.0.0' formats
    const targetVersion = spec.revision
    const targetVersionWithV = `v${spec.revision}`

    const targetIndex = packageVersions.findIndex(
      versionObj => versionObj.version === targetVersion || versionObj.version === targetVersionWithV
    )
    if (targetIndex === -1) return null

    const combined = {}
    for (let i = 0; i <= targetIndex; i++) {
      for (const [key, value] of Object.entries(packageVersions[i])) {
        if (value === '__unset') {
          delete combined[key]
        } else {
          combined[key] = value
        }
      }
    }
    return combined
  }

  async _getPackage(request, registryData, destination) {
    const distUrl = get(registryData, 'manifest.dist.url')
    if (!distUrl) return request.markSkip('Missing dist.url ')
    const response = await getStream({ url: distUrl })
    if (response.statusCode !== 200) throw new Error(`${response.statusCode} ${response.message}`)
    await new Promise(resolve => {
      response.data.pipe(fs.createWriteStream(destination)).on('finish', () => resolve(null))
    })
  }

  async _getDirRoot(location) {
    return (await readdir(location))[0]
  }

  _createDocument(dir, registryData, hashes) {
    const releaseDate = registryData.releaseDate
    return { location: dir.name, registryData, releaseDate, hashes }
  }
}

module.exports = options => new PackagistFetch(options)