npq 3.7.0 → 3.8.0

package/__tests__/marshalls.tasks.test.js

@@ -53,3 +53,54 @@ test('running marshall tasks fails', async () => {
 
   await expect(marshalls.tasks(config)).resolves.toMatchObject(context)
 })
+
+test('running marshall tasks throws error when single package is not found', async () => {
+  const PackageRepoUtilsNotFoundMock = class Fake {
+    getPackageInfo() {
+      return Promise.resolve({ error: 'Not found' })
+    }
+  }
+
+  marshalls.collectMarshalls = jest.fn(() => {
+    return Promise.resolve([path.join(process.cwd(), '__tests__/__fixtures__/test.marshall.js')])
+  })
+
+  const config = {
+    pkgs: [{ packageName: 'nonexistent-package' }],
+    packageRepoUtils: new PackageRepoUtilsNotFoundMock()
+  }
+
+  await expect(marshalls.tasks(config)).resolves.toEqual({
+    error: true,
+    message: 'Package not found: nonexistent-package'
+  })
+})
+
+test('running marshall tasks filters out not found packages when multiple packages provided', async () => {
+  const PackageRepoUtilsMixedMock = class Fake {
+    getPackageInfo(packageName) {
+      if (packageName === 'nonexistent-package') {
+        return Promise.resolve({ error: 'Not found' })
+      }
+      return Promise.resolve(true)
+    }
+  }
+
+  marshalls.collectMarshalls = jest.fn(() => {
+    return Promise.resolve([path.join(process.cwd(), '__tests__/__fixtures__/test.marshall.js')])
+  })
+
+  const config = {
+    pkgs: [
+      { packageName: 'express' },
+      { packageName: 'nonexistent-package' },
+      { packageName: 'semver' }
+    ],
+    packageRepoUtils: new PackageRepoUtilsMixedMock()
+  }
+
+  const result = await marshalls.tasks(config)
+  // Should filter out the nonexistent package and keep only express and semver
+  expect(result.pkgs).toHaveLength(2)
+  expect(result.pkgs).toEqual([{ packageName: 'express' }, { packageName: 'semver' }])
+})

package/__tests__/packageRepoUtils.test.js

@@ -160,3 +160,92 @@ test('repo utils returns valid semver for different cases of version asked', asy
     'could not find dist-tag next for package testPackage'
   )
 })
+
+test('repo utils resolves semver ranges by finding the highest satisfying version', async () => {
+  const PackageRepoUtils = require('../lib/helpers/packageRepoUtils')
+  global.fetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      json: () => require('./mocks/registryPackageOk.mock.json')
+    })
+  )
+
+  const packageRepoUtils = new PackageRepoUtils()
+  const packageName = 'testPackage'
+
+  // Test major version range - should find highest 3.x version (3.1.0)
+  let result = await packageRepoUtils.getSemVer(packageName, '^3.0.0')
+  expect(result).toEqual('3.1.0')
+
+  // Test simple major version - should find highest 3.x version (3.1.0)
+  result = await packageRepoUtils.getSemVer(packageName, '3')
+  expect(result).toEqual('3.1.0')
+
+  // Test tilde range - should find 3.1.x version (3.1.0)
+  result = await packageRepoUtils.getSemVer(packageName, '~3.1.0')
+  expect(result).toEqual('3.1.0')
+
+  // Test invalid semver range that doesn't match any version
+  await expect(packageRepoUtils.getSemVer(packageName, '^10.0.0')).rejects.toThrow(
+    'could not find dist-tag ^10.0.0 for package testPackage'
+  )
+
+  // Test invalid semver range with version 2 (no 2.x versions in mock)
+  await expect(packageRepoUtils.getSemVer(packageName, '2')).rejects.toThrow(
+    'could not find dist-tag 2 for package testPackage'
+  )
+})
+
+test('repo utils resolves semver ranges with multiple versions', async () => {
+  const PackageRepoUtils = require('../lib/helpers/packageRepoUtils')
+
+  // Create a more comprehensive mock that includes multiple versions
+  const comprehensiveMock = {
+    name: '@astrojs/vue',
+    'dist-tags': {
+      latest: '4.5.0'
+    },
+    versions: {
+      '1.2.0': { name: '@astrojs/vue', version: '1.2.0' },
+      '2.0.0': { name: '@astrojs/vue', version: '2.0.0' },
+      '2.1.0': { name: '@astrojs/vue', version: '2.1.0' },
+      '2.2.1': { name: '@astrojs/vue', version: '2.2.1' },
+      '3.0.0': { name: '@astrojs/vue', version: '3.0.0' },
+      '3.1.0': { name: '@astrojs/vue', version: '3.1.0' },
+      '3.2.2': { name: '@astrojs/vue', version: '3.2.2' },
+      '4.0.0': { name: '@astrojs/vue', version: '4.0.0' },
+      '4.5.0': { name: '@astrojs/vue', version: '4.5.0' }
+    }
+  }
+
+  global.fetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      json: () => comprehensiveMock
+    })
+  )
+
+  const packageRepoUtils = new PackageRepoUtils()
+  const packageName = '@astrojs/vue'
+
+  // Test the problematic case mentioned in the issue: "@astrojs/vue@3"
+  let result = await packageRepoUtils.getSemVer(packageName, '3')
+  expect(result).toEqual('3.2.2') // Should find highest 3.x version
+
+  // Test other major versions
+  result = await packageRepoUtils.getSemVer(packageName, '2')
+  expect(result).toEqual('2.2.1') // Should find highest 2.x version
+
+  result = await packageRepoUtils.getSemVer(packageName, '4')
+  expect(result).toEqual('4.5.0') // Should find highest 4.x version
+
+  // Test caret ranges
+  result = await packageRepoUtils.getSemVer(packageName, '^3.0.0')
+  expect(result).toEqual('3.2.2')
+
+  result = await packageRepoUtils.getSemVer(packageName, '^2.1.0')
+  expect(result).toEqual('2.2.1')
+
+  // Test that non-existent major versions still fail appropriately
+  await expect(packageRepoUtils.getSemVer(packageName, '10')).rejects.toThrow(
+    'could not find dist-tag 10 for package @astrojs/vue'
+  )
+})

package/lib/helpers/packageRepoUtils.js

@@ -64,13 +64,28 @@ class PackageRepoUtils {
         throw new Error(`could not find dist-tags for package ${packageName}`)
       }
 
-      if (packageInfo['dist-tags'][packageVersion] === undefined) {
-        throw new Error(`could not find dist-tag ${packageVersion} for package ${packageName}`)
+      if (packageInfo['dist-tags'][packageVersion] !== undefined) {
+        const semverVersion = packageInfo['dist-tags'][packageVersion]
+        return semverVersion
       }
 
-      const semverVersion = packageInfo['dist-tags'][packageVersion]
+      // If not found in dist-tags, try to find the highest version that satisfies
+      // the semver range from the versions object
+      if (packageInfo.versions) {
+        const availableVersions = Object.keys(packageInfo.versions).filter((v) => semver.valid(v))
 
-      return semverVersion
+        try {
+          const satisfyingVersion = semver.maxSatisfying(availableVersions, packageVersion)
+
+          if (satisfyingVersion) {
+            return satisfyingVersion
+          }
+        } catch (error) {
+          // semver.maxSatisfying throws if the range is invalid, continue to error below
+        }
+      }
+
+      throw new Error(`could not find dist-tag ${packageVersion} for package ${packageName}`)
     }
   }
 }

package/lib/marshalls/index.js

@@ -65,7 +65,26 @@ class Marshalls {
   }
 
   static tasks(options) {
+    // console.log(options);
+    // process.exit(1);
     return Marshalls.warmUpPackagesCache(options)
+      .then((packagesDataList) => {
+        // handle error in case we get just one package and it is not found
+        if (packagesDataList && packagesDataList.length === 1) {
+          if (packagesDataList[0].error && packagesDataList[0].error === 'Not found') {
+            throw new Error(`Package not found: ${options.pkgs[0].packageName}`)
+          }
+        }
+
+        // handle error in case we get more than one package and at least one is not found
+        // in which we case we simply remove the package from the `options` array
+        // which lists objects (each have a property of packageName)
+        if (packagesDataList && packagesDataList.length > 1) {
+          options.pkgs = options.pkgs.filter((pkg, index) => {
+            return !packagesDataList[index].error || packagesDataList[index].error !== 'Not found'
+          })
+        }
+      })
       .then(() => Marshalls.collectMarshalls())
       .then((marshalls) => {
         return Marshalls.buildMarshallTasks(marshalls, {
@@ -75,6 +94,12 @@ class Marshalls {
       .then((tasks) => {
         return Marshalls.runTasks(tasks, options)
       })
+      .catch((err) => {
+        // console.error('Error:', err.message)
+        // avoid implementing a custom error message for a not found package
+        // because the package manager will yield its own error message
+        return { error: true, message: err.message }
+      })
   }
 
   static warmUpPackagesCache(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npq",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "marshall your npm/npm package installs with high quality and class 🎖",
   "bin": {
     "npq": "./bin/npq.js",
@@ -135,7 +135,7 @@
       "security/detect-no-csrf-before-method-override": "error",
       "security/detect-non-literal-regexp": "error",
       "security/detect-non-literal-require": "warn",
-      "security/detect-object-injection": "warn",
+      "security/detect-object-injection": "off",
       "security/detect-possible-timing-attacks": "error",
       "security/detect-pseudoRandomBytes": "error",
       "node/no-unsupported-features/node-builtins": [