287 lines
9.8 KiB
JavaScript
287 lines
9.8 KiB
JavaScript
const http = require('http')
|
|
const tmpdir = require('os-tmpdir')
|
|
const { join: joinPaths } = require('path')
|
|
const { stat: statFile, readFile } = require('fs')
|
|
const { maxSatisfying: maxSatisfyingVersion } = require('semver')
|
|
const { parsePackageURL, createPackageURL } = require('./PackageUtils')
|
|
const { getPackageInfo, getPackage } = require('./RegistryUtils')
|
|
const { generateDirectoryIndexHTML } = require('./IndexUtils')
|
|
const { generateMetadata } = require('./MetadataUtils')
|
|
const { getFileType } = require('./FileUtils')
|
|
const {
|
|
sendNotFoundError,
|
|
sendInvalidURLError,
|
|
sendServerError,
|
|
sendRedirect,
|
|
sendFile,
|
|
sendText,
|
|
sendJSON,
|
|
sendHTML
|
|
} = require('./ResponseUtils')
|
|
|
|
const OneMinute = 60
|
|
const OneDay = OneMinute * 60 * 24
|
|
const OneYear = OneDay * 365
|
|
|
|
const checkLocalCache = (dir, callback) =>
|
|
statFile(joinPaths(dir, 'package.json'), (error, stats) => {
|
|
callback(stats && stats.isFile())
|
|
})
|
|
|
|
const ResolveExtensions = [ '', '.js', '.json' ]
|
|
|
|
const createTempPath = (name) =>
|
|
joinPaths(tmpdir(), `express-unpkg-${name}`)
|
|
|
|
/**
|
|
* Resolves a path like "lib/file" into "lib/file.js" or
|
|
* "lib/file.json" depending on which one is available, similar
|
|
* to how require('lib/file') does.
|
|
*/
|
|
const resolveFile = (path, useIndex, callback) => {
|
|
ResolveExtensions.reduceRight((next, ext) => {
|
|
const file = path + ext
|
|
|
|
return () => {
|
|
statFile(file, (error, stats) => {
|
|
if (error) {
|
|
if (error.code === 'ENOENT' || error.code === 'ENOTDIR') {
|
|
next()
|
|
} else {
|
|
callback(error)
|
|
}
|
|
} else if (useIndex && stats.isDirectory()) {
|
|
resolveFile(joinPaths(file, 'index'), false, (error, indexFile, indexStats) => {
|
|
if (error) {
|
|
callback(error)
|
|
} else if (indexFile) {
|
|
callback(null, indexFile, indexStats)
|
|
} else {
|
|
next()
|
|
}
|
|
})
|
|
} else {
|
|
callback(null, file, stats)
|
|
}
|
|
})
|
|
}
|
|
}, callback)()
|
|
}
|
|
|
|
/**
|
|
* Creates and returns a function that can be used in the "request"
|
|
* event of a standard node HTTP server. Options are:
|
|
*
|
|
* - registryURL The URL of the npm registry (defaults to https://registry.npmjs.org)
|
|
* - redirectTTL The TTL (in seconds) for redirects (defaults to 0)
|
|
* - autoIndex Automatically generate index HTML pages for directories (defaults to true)
|
|
*
|
|
* Supported URL schemes are:
|
|
*
|
|
* /history@1.12.5/umd/History.min.js (recommended)
|
|
* /history@1.12.5 (package.json's main is implied)
|
|
*
|
|
* Additionally, the following URLs are supported but will return a
|
|
* temporary (302) redirect:
|
|
*
|
|
* /history (redirects to version, latest is implied)
|
|
* /history/umd/History.min.js (redirects to version, latest is implied)
|
|
* /history@latest/umd/History.min.js (redirects to version)
|
|
* /history@^1/umd/History.min.js (redirects to max satisfying version)
|
|
*/
|
|
const createRequestHandler = (options = {}) => {
|
|
const registryURL = options.registryURL || 'https://registry.npmjs.org'
|
|
const redirectTTL = options.redirectTTL || 0
|
|
const autoIndex = options.autoIndex !== false
|
|
const maximumDepth = options.maximumDepth || Number.MAX_VALUE
|
|
const blacklist = options.blacklist || []
|
|
|
|
const handleRequest = (req, res) => {
|
|
let url
|
|
try {
|
|
url = parsePackageURL(req.url)
|
|
} catch (error) {
|
|
return sendInvalidURLError(res, req.url)
|
|
}
|
|
|
|
if (url == null)
|
|
return sendInvalidURLError(res, req.url)
|
|
|
|
const { pathname, search, query, packageName, version, filename } = url
|
|
const displayName = `${packageName}@${version}`
|
|
|
|
const isBlacklisted = blacklist.indexOf(packageName) !== -1
|
|
|
|
if (isBlacklisted)
|
|
return sendText(res, 403, `Package ${packageName} is blacklisted`)
|
|
|
|
// Step 1: Fetch the package from the registry and store a local copy.
|
|
// Redirect if the URL does not specify an exact version number.
|
|
const fetchPackage = (next) => {
|
|
const packageDir = createTempPath(displayName)
|
|
|
|
checkLocalCache(packageDir, (isCached) => {
|
|
if (isCached)
|
|
return next(packageDir) // Best case: we already have this package on disk.
|
|
|
|
// Fetch package info from NPM registry.
|
|
getPackageInfo(registryURL, packageName, (error, packageInfo) => {
|
|
if (error)
|
|
return sendServerError(res, error)
|
|
|
|
if (packageInfo == null)
|
|
return sendNotFoundError(res, `package "${packageName}"`)
|
|
|
|
if (packageInfo.versions == null)
|
|
return sendServerError(res, new Error(`Unable to retrieve info for package ${packageName}`))
|
|
|
|
const { versions, 'dist-tags': tags } = packageInfo
|
|
|
|
if (version in versions) {
|
|
// A valid request for a package we haven't downloaded yet.
|
|
const packageConfig = versions[version]
|
|
const tarballURL = packageConfig.dist.tarball
|
|
|
|
getPackage(tarballURL, packageDir, (error) => {
|
|
if (error) {
|
|
sendServerError(res, error)
|
|
} else {
|
|
next(packageDir)
|
|
}
|
|
})
|
|
} else if (version in tags) {
|
|
sendRedirect(res, createPackageURL(packageName, tags[version], filename, search), redirectTTL)
|
|
} else {
|
|
const maxVersion = maxSatisfyingVersion(Object.keys(versions), version)
|
|
|
|
if (maxVersion) {
|
|
sendRedirect(res, createPackageURL(packageName, maxVersion, filename, search), redirectTTL)
|
|
} else {
|
|
sendNotFoundError(res, `package ${displayName}`)
|
|
}
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
// Step 2: Determine which file we're going to serve and get its stats.
|
|
// Redirect if the request targets a directory with no trailing slash.
|
|
const findFile = (packageDir, next) => {
|
|
if (filename) {
|
|
const path = joinPaths(packageDir, filename)
|
|
|
|
// Based on the URL, figure out which file they want.
|
|
resolveFile(path, false, (error, file, stats) => {
|
|
if (error) {
|
|
sendServerError(res, error)
|
|
} else if (file == null) {
|
|
sendNotFoundError(res, `file "${filename}" in package ${displayName}`)
|
|
} else if (stats.isDirectory() && pathname[pathname.length - 1] !== '/') {
|
|
// Append `/` to directory URLs
|
|
sendRedirect(res, pathname + '/' + search, OneYear)
|
|
} else {
|
|
next(file.replace(packageDir, ''), stats)
|
|
}
|
|
})
|
|
} else {
|
|
// No filename in the URL. Try to serve the package's "main" file.
|
|
readFile(joinPaths(packageDir, 'package.json'), 'utf8', (error, data) => {
|
|
if (error)
|
|
return sendServerError(res, error)
|
|
|
|
let packageConfig
|
|
try {
|
|
packageConfig = JSON.parse(data)
|
|
} catch (error) {
|
|
return sendText(res, 500, `Error parsing ${displayName}/package.json: ${error.message}`)
|
|
}
|
|
|
|
let mainFilename
|
|
const queryMain = query && query.main
|
|
|
|
if (queryMain) {
|
|
if (!(queryMain in packageConfig))
|
|
return sendNotFoundError(res, `field "${queryMain}" in ${displayName}/package.json`)
|
|
|
|
mainFilename = packageConfig[queryMain]
|
|
} else {
|
|
if (typeof packageConfig.unpkg === 'string') {
|
|
// The "unpkg" field allows packages to explicitly declare the
|
|
// file to serve at the bare URL (see #59).
|
|
mainFilename = packageConfig.unpkg
|
|
} else if (typeof packageConfig.browser === 'string') {
|
|
// Fall back to the "browser" field if declared (only support strings).
|
|
mainFilename = packageConfig.browser
|
|
} else {
|
|
// If there is no main, use "index" (same as npm).
|
|
mainFilename = packageConfig.main || 'index'
|
|
}
|
|
}
|
|
|
|
resolveFile(joinPaths(packageDir, mainFilename), true, (error, file, stats) => {
|
|
if (error) {
|
|
sendServerError(res, error)
|
|
} else if (file == null) {
|
|
sendNotFoundError(res, `main file "${mainFilename}" in package ${displayName}`)
|
|
} else {
|
|
next(file.replace(packageDir, ''), stats)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
// Step 3: Send the file, JSON metadata, or HTML directory listing.
|
|
const serveFile = (baseDir, path, stats) => {
|
|
if (query.json != null) {
|
|
generateMetadata(baseDir, path, stats, maximumDepth, (error, metadata) => {
|
|
if (metadata) {
|
|
sendJSON(res, metadata, OneYear)
|
|
} else {
|
|
sendServerError(res, `unable to generate JSON metadata for ${displayName}${filename}`)
|
|
}
|
|
})
|
|
} else if (stats.isFile()) {
|
|
sendFile(res, joinPaths(baseDir, path), stats, OneYear)
|
|
} else if (autoIndex && stats.isDirectory()) {
|
|
getPackageInfo(registryURL, packageName, (error, packageInfo) => {
|
|
if (error) {
|
|
sendServerError(res, `unable to generate index page for ${displayName}${filename}`)
|
|
} else {
|
|
generateDirectoryIndexHTML(packageInfo, version, baseDir, path, (error, html) => {
|
|
if (html) {
|
|
sendHTML(res, html, OneYear)
|
|
} else {
|
|
sendServerError(res, `unable to generate index page for ${displayName}${filename}`)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
} else {
|
|
sendInvalidURLError(res, `${displayName}${filename} is a ${getFileType(stats)}`)
|
|
}
|
|
}
|
|
|
|
fetchPackage(packageDir => {
|
|
findFile(packageDir, (file, stats) => {
|
|
serveFile(packageDir, file, stats)
|
|
})
|
|
})
|
|
}
|
|
|
|
return handleRequest
|
|
}
|
|
|
|
/**
|
|
* Creates and returns an HTTP server that serves files from NPM packages.
|
|
*/
|
|
const createServer = (options) =>
|
|
http.createServer(
|
|
createRequestHandler(options)
|
|
)
|
|
|
|
module.exports = {
|
|
createRequestHandler,
|
|
createServer
|
|
}
|