verdaccio/build/api/web/api/package.mjs

A lightweight private npm proxy registry

import { DIST_TAGS, HEADERS, HEADER_TYPE, HTTP_STATUS } from "../../../lib/constants.mjs";
import { logger } from "../../../lib/logger/index.mjs";
import { ErrorCode, addScope, deleteProperties, isVersionValid, parseReadme, sortByName } from "../../../lib/utils.mjs";
import { wrapPath } from "./utils.mjs";
import _ from "lodash";
import { WebUrls, allow } from "@verdaccio/middleware";
import { addGravatarSupport, formatAuthor, generateGravatarUrl } from "@verdaccio/utils";
import { convertDistRemoteToLocalTarballUrls, getLocalRegistryTarballUri } from "@verdaccio/tarball";
import { createAnonymousRemoteUser } from "@verdaccio/config";
import { Router } from "express";
//#region src/api/web/api/package.ts
var getOrder = (order = "asc") => {
	return order === "asc";
};
function addPackageWebApi(storage, auth, config) {
	const pkgRouter = Router();
	const can = allow(auth, {
		beforeAll: (params, message) => {
			logger.debug(params, message);
		},
		afterAll: (params, message) => logger.debug(params, message)
	});
	const checkAllow = (name, remoteUser) => new Promise((resolve, reject) => {
		try {
			const isLoginEnabled = _.isNil(config?.web?.login) || config?.web?.login === true;
			const anonymousRemoteUser = createAnonymousRemoteUser();
			const remoteUserAccess = !isLoginEnabled ? anonymousRemoteUser : remoteUser;
			auth.allow_access({ packageName: name }, remoteUserAccess, (err, allowed) => {
				if (err) resolve(false);
				resolve(allowed);
			});
		} catch (err) {
			reject(err);
		}
	});
	pkgRouter.get(wrapPath(WebUrls.packages_all), function(req, res, next) {
		storage.getLocalDatabase(async function(err, packages) {
			if (err) throw err;
			async function processPackages(packages = []) {
				const permissions = [];
				const packgesCopy = packages.slice();
				for (const pkg of packgesCopy) {
					const pkgCopy = { ...pkg };
					pkgCopy.author = formatAuthor(pkg.author);
					try {
						if (await checkAllow(pkg.name, req.remote_user)) {
							if (config.web) pkgCopy.author.avatar = generateGravatarUrl(pkgCopy.author.email, config.web.gravatar);
							if (!_.isNil(pkgCopy.dist) && !_.isNull(pkgCopy.dist.tarball)) pkgCopy.dist.tarball = getLocalRegistryTarballUri(pkgCopy.dist.tarball, pkg.name, {
								protocol: req.protocol,
								headers: req.headers,
								host: req.hostname
							}, config.url_prefix);
							permissions.push(pkgCopy);
						}
					} catch (err) {
						logger.error({
							name: pkg.name,
							error: err
						}, "permission process for @{name} has failed: @{error}");
						throw err;
					}
				}
				return permissions;
			}
			const order = config.web ? getOrder(config.web?.sort_packages) : true;
			try {
				next(sortByName(await processPackages(packages), order));
			} catch (error) {
				next(ErrorCode.getInternalError(error.message));
			}
		});
	});
	pkgRouter.get([wrapPath(WebUrls.readme_package_scoped_version), wrapPath(WebUrls.readme_package_version)], can("access"), function(req, res, next) {
		const rawScope = req.params.scope;
		const scope = rawScope ? rawScope.slice(1) : null;
		const packageName = scope ? addScope(scope, req.params.package) : req.params.package;
		storage.getPackage({
			name: packageName,
			uplinksLook: true,
			req,
			callback: function(err, info) {
				if (err) return next(err);
				res.set(HEADER_TYPE.CONTENT_TYPE, HEADERS.TEXT_PLAIN);
				next(parseReadme(info.name, info.readme));
			}
		});
	});
	pkgRouter.get([wrapPath(WebUrls.sidebar_scopped_package), wrapPath(WebUrls.sidebar_package)], can("access"), function(req, res, next) {
		const rawScope = req.params.scope;
		const scope = rawScope ? rawScope.slice(1) : null;
		const packageName = scope ? addScope(scope, req.params.package) : req.params.package;
		storage.getPackage({
			name: packageName,
			uplinksLook: true,
			keepUpLinkData: true,
			req,
			callback: function(err, info) {
				if (_.isNil(err)) {
					const { v } = req.query;
					let sideBarInfo = _.clone(info);
					sideBarInfo.versions = convertDistRemoteToLocalTarballUrls(info, {
						protocol: req.protocol,
						headers: req.headers,
						host: req.hostname
					}, config.url_prefix).versions;
					if (isVersionValid(info, v)) {
						sideBarInfo.latest = sideBarInfo.versions[v];
						sideBarInfo.latest.author = formatAuthor(sideBarInfo.latest.author);
					} else {
						sideBarInfo.latest = sideBarInfo.versions[info[DIST_TAGS].latest];
						if (sideBarInfo?.latest) sideBarInfo.latest.author = formatAuthor(sideBarInfo.latest.author);
						else {
							res.status(HTTP_STATUS.NOT_FOUND);
							res.end();
							return;
						}
					}
					sideBarInfo = deleteProperties([
						"readme",
						"_attachments",
						"_rev",
						"name"
					], sideBarInfo);
					if (config.web) sideBarInfo = addGravatarSupport(sideBarInfo, config.web.gravatar);
					else sideBarInfo = addGravatarSupport(sideBarInfo);
					next(sideBarInfo);
				} else {
					res.status(HTTP_STATUS.NOT_FOUND);
					res.end();
				}
			}
		});
	});
	return pkgRouter;
}
//#endregion
export { addPackageWebApi as default };

//# sourceMappingURL=package.mjs.map