@verdaccio/store 6.0.0-6-next.21 → 6.0.0-6-next.24

package/src/lib/uplink-util.ts

@@ -0,0 +1,41 @@
+import { IProxy, ProxyStorage } from '@verdaccio/proxy';
+import { Config, Manifest } from '@verdaccio/types';
+
+export interface ProxyInstanceList {
+  [key: string]: IProxy;
+}
+
+/**
+ * Set up the Up Storage for each link.
+ */
+export function setupUpLinks(config: Config): ProxyInstanceList {
+  const uplinks: ProxyInstanceList = {};
+
+  for (const uplinkName in config.uplinks) {
+    if (Object.prototype.hasOwnProperty.call(config.uplinks, uplinkName)) {
+      // instance for each up-link definition
+      const proxy: IProxy = new ProxyStorage(config.uplinks[uplinkName], config);
+      // TODO: review this can be inside ProxyStorage
+      proxy.upname = uplinkName;
+
+      uplinks[uplinkName] = proxy;
+    }
+  }
+
+  return uplinks;
+}
+
+export function updateVersionsHiddenUpLinkNext(manifest: Manifest, upLink: IProxy): Manifest {
+  const { versions } = manifest;
+  const versionsList = Object.keys(versions);
+  if (versionsList.length === 0) {
+    return manifest;
+  }
+
+  for (const version of versionsList) {
+    // holds a "hidden" value to be used by the package storage.
+    versions[version][Symbol.for('__verdaccio_uplink')] = upLink.upname;
+  }
+
+  return { ...manifest, versions: versions };
+}

package/src/lib/versions-utils.ts

@@ -0,0 +1,87 @@
+import _ from 'lodash';
+import semver, { SemVer } from 'semver';
+
+import { DIST_TAGS } from '@verdaccio/core';
+import { Manifest, StringValue, Version, Versions } from '@verdaccio/types';
+
+/**
+ * Gets version from a package object taking into account semver weirdness.
+ * @return {String} return the semantic version of a package
+ */
+export function getVersion(versions: Versions, version: string): Version | undefined {
+  if (!versions) {
+    return;
+  }
+
+  // this condition must allow cast
+  if (_.isNil(versions[version]) === false) {
+    return versions[version];
+  }
+
+  const versionSemver: SemVer | null = semver.parse(version, true);
+  if (versionSemver === null) {
+    return;
+  }
+
+  for (const versionItem in versions) {
+    if (Object.prototype.hasOwnProperty.call(versions, versionItem)) {
+      // @ts-ignore
+      if (versionSemver.compare(semver.parse(versionItem, true)) === 0) {
+        return versions[versionItem];
+      }
+    }
+  }
+}
+
+/**
+ * Function filters out bad semver versions and sorts the array.
+ * @return {Array} sorted Array
+ */
+export function sortVersionsAndFilterInvalid(listVersions: string[] /* logger */): string[] {
+  return (
+    listVersions
+      .filter(function (version): boolean {
+        if (!semver.parse(version, true)) {
+          return false;
+        }
+        return true;
+      })
+      // FIXME: it seems the @types/semver do not handle a legitimate method named 'compareLoose'
+      // @ts-ignore
+      .sort(semver.compareLoose)
+      .map(String)
+  );
+}
+
+/**
+ * Create a tag for a package
+ * @param {*} data
+ * @param {*} version
+ * @param {*} tag
+ * @return {Boolean} whether a package has been tagged
+ * @deprecated
+ */
+export function tagVersion(data: Manifest, version: string, tag: StringValue): boolean {
+  if (tag && data[DIST_TAGS][tag] !== version && semver.parse(version, true)) {
+    // valid version - store
+    data[DIST_TAGS][tag] = version;
+    return true;
+  }
+  return false;
+}
+
+/**
+ *
+ * @param manifest
+ * @param version
+ * @param tag
+ * @returns
+ */
+export function tagVersionNext(manifest: Manifest, version: string, tag: StringValue): Manifest {
+  const data = { ...manifest };
+  if (tag && data[DIST_TAGS][tag] !== version && semver.parse(version, true)) {
+    // valid version - store
+    data[DIST_TAGS][tag] = version;
+  }
+  return data;
+}