@vltpkg/vsr 0.2.0 → 0.2.1

package/test/packument-consistency.test.js

@@ -1,351 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { getPackagePackument } from '../src/routes/packages.ts'
-
-// Mock config
-vi.mock('../../config.js', () => ({
-  DOMAIN: 'https://registry.example.com',
-  PROXY: true,
-  PROXY_URL: 'https://registry.npmjs.org'
-}))
-
-// Mock slimManifest function
-vi.mock('../src/utils/packages.js', () => ({
-  slimManifest: (manifest) => {
-    // Simple implementation to use in tests
-    if (!manifest) return {}
-
-    const parsed = typeof manifest === 'string' ? JSON.parse(manifest) : manifest
-
-    // Create a simplified version with only essential fields
-    const slimmed = {
-      name: parsed.name,
-      version: parsed.version,
-      description: parsed.description,
-      dependencies: parsed.dependencies || {},
-      peerDependencies: parsed.peerDependencies || {},
-      peerDependenciesMeta: parsed.peerDependenciesMeta || {},
-      dist: {
-        ...(parsed.dist || {}),
-        tarball: parsed.dist?.tarball || ''
-      }
-    }
-
-    // Remove undefined values
-    Object.keys(slimmed).forEach(key => {
-      if (key !== 'dist' && slimmed[key] === undefined) {
-        delete slimmed[key]
-      }
-    })
-
-    return slimmed
-  },
-  createVersion: ({ pkg, version, manifest }) => manifest
-}))
-
-describe('Packument Response Format', () => {
-  // Set up mock data and context
-  const setupTest = () => {
-    // Mock package data
-    const mockPublishedPackage = {
-      name: 'local-package',
-      tags: { latest: '1.0.0', beta: '1.1.0-beta.1' },
-      lastUpdated: '2023-01-01T00:00:00.000Z'
-    }
-
-    // Mock version data with JSON strings
-    const mockVersions = [
-      {
-        spec: 'local-package@1.0.0',
-        version: '1.0.0',
-        manifest: JSON.stringify({
-          name: 'local-package',
-          version: '1.0.0',
-          description: 'A locally published package',
-          dependencies: { 'some-dep': '^1.0.0' },
-          _id: 'local-package@1.0.0',
-          _npmUser: { name: 'testuser' },
-          readme: 'Very long readme content...',
-          dist: {
-            shasum: '1234567890abcdef',
-            integrity: 'sha512-abcdefghijklmnopqrstuvwxyz0123456789',
-            tarball: 'https://registry.example.com/local-package/-/local-package-1.0.0.tgz'
-          }
-        }),
-        published_at: '2023-01-01T00:00:00.000Z'
-      },
-      {
-        spec: 'local-package@1.1.0-beta.1',
-        version: '1.1.0-beta.1',
-        manifest: JSON.stringify({
-          name: 'local-package',
-          version: '1.1.0-beta.1',
-          description: 'A locally published package (beta)',
-          dependencies: {
-            'some-dep': '^1.0.0',
-            'another-dep': '^2.0.0'
-          },
-          _id: 'local-package@1.1.0-beta.1',
-          _npmUser: { name: 'testuser' },
-          readme: 'Very long readme content for beta...',
-          dist: {
-            shasum: '0987654321fedcba',
-            integrity: 'sha512-zyxwvutsrqponmlkjihgfedcba0987654321',
-            tarball: 'https://registry.example.com/local-package/-/local-package-1.1.0-beta.1.tgz'
-          }
-        }),
-        published_at: '2023-01-15T00:00:00.000Z'
-      }
-    ]
-
-    // Set up mock context
-    const mockContext = {
-      req: {
-        param: vi.fn((name) => {
-          if (name === 'pkg') {
-            return 'local-package'
-          }
-          return undefined
-        }),
-        query: vi.fn((name) => {
-          return null; // Return null for any query param
-        }),
-        url: 'https://registry.example.com/local-package'
-      },
-      db: {
-        getPackage: vi.fn(async (name) => {
-          if (name === 'local-package') {
-            return { ...mockPublishedPackage }
-          }
-          return null
-        }),
-        getVersionsByPackage: vi.fn(async (name) => {
-          if (name === 'local-package') {
-            return [...mockVersions]
-          }
-          return []
-        }),
-        getVersion: vi.fn(async (spec) => {
-          return mockVersions.find(v => v.spec === spec)
-        }),
-        upsertPackage: vi.fn(async () => true),
-        upsertVersion: vi.fn(async () => true)
-      },
-      json: vi.fn((data, status = 200) => ({ body: data, status })),
-      header: vi.fn(),
-      executionCtx: { waitUntil: vi.fn() },
-      env: {}
-    }
-
-    // Mock upstream data
-    const mockUpstreamData = {
-      name: 'proxied-package',
-      _id: 'proxied-package',
-      _rev: '123-abc',
-      _attachments: {},
-      _npmUser: { name: 'upstream-user' },
-      maintainers: [{ name: 'upstream-user', email: 'user@example.com' }],
-      'dist-tags': { latest: '2.0.0', next: '2.1.0-rc.1' },
-      versions: {
-        '2.0.0': {
-          name: 'proxied-package',
-          version: '2.0.0',
-          description: 'A proxied package',
-          dependencies: { 'dep1': '^1.0.0' },
-          _id: 'proxied-package@2.0.0',
-          _npmUser: { name: 'upstream-user' },
-          readme: 'Very long readme content...',
-          dist: {
-            shasum: 'abcdef1234567890',
-            integrity: 'sha512-abcdefghijklmnopqrstuvwxyz0123456789',
-            tarball: 'https://registry.npmjs.org/proxied-package/-/proxied-package-2.0.0.tgz'
-          }
-        },
-        '2.1.0-rc.1': {
-          name: 'proxied-package',
-          version: '2.1.0-rc.1',
-          description: 'A proxied package (RC)',
-          dependencies: { 'dep1': '^1.0.0', 'dep2': '^3.0.0' },
-          _id: 'proxied-package@2.1.0-rc.1',
-          _npmUser: { name: 'upstream-user' },
-          readme: 'Very long readme content for RC...',
-          dist: {
-            shasum: 'fedcba0987654321',
-            integrity: 'sha512-zyxwvutsrqponmlkjihgfedcba0987654321',
-            tarball: 'https://registry.npmjs.org/proxied-package/-/proxied-package-2.1.0-rc.1.tgz'
-          }
-        }
-      },
-      time: {
-        modified: '2023-02-01T00:00:00.000Z',
-        created: '2023-01-01T00:00:00.000Z',
-        '2.0.0': '2023-01-15T00:00:00.000Z',
-        '2.1.0-rc.1': '2023-02-01T00:00:00.000Z'
-      }
-    }
-
-    // Mock fetch for proxied package
-    global.fetch = vi.fn(async (url) => {
-      if (url.includes('proxied-package')) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({ ...mockUpstreamData })
-        }
-      }
-      return {
-        ok: false,
-        status: 404,
-        json: async () => ({ error: 'Not found' })
-      }
-    })
-
-    return {
-      mockContext,
-      mockUpstreamData,
-      mockPublishedPackage,
-      mockVersions
-    }
-  }
-
-  beforeEach(() => {
-    vi.resetAllMocks()
-  })
-
-  it('should return consistent packument for local packages with only required fields', async () => {
-    const { mockContext } = setupTest()
-
-    await getPackagePackument(mockContext)
-
-    expect(mockContext.json).toHaveBeenCalled()
-    const responseData = mockContext.json.mock.calls[0][0]
-
-    // Verify structure
-    expect(responseData).toHaveProperty('name', 'local-package')
-    expect(responseData).toHaveProperty('dist-tags')
-    expect(responseData).toHaveProperty('versions')
-    expect(responseData).toHaveProperty('time')
-
-    // Verify dist-tags
-    expect(responseData['dist-tags']).toEqual({
-      latest: '1.0.0',
-      beta: '1.1.0-beta.1'
-    })
-
-    // Verify versions exist
-    expect(responseData.versions).toHaveProperty('1.0.0')
-    expect(responseData.versions).toHaveProperty('1.1.0-beta.1')
-
-    // Check slimming of sensitive data
-    const version = responseData.versions['1.0.0']
-    expect(version).toBeDefined()
-    expect(version).not.toHaveProperty('_id')
-    expect(version).not.toHaveProperty('_npmUser')
-    expect(version).not.toHaveProperty('readme')
-
-    // Verify contains required fields
-    expect(version).toHaveProperty('name', 'local-package')
-    expect(version).toHaveProperty('version', '1.0.0')
-    expect(version).toHaveProperty('dist')
-
-    // Verify status
-    expect(mockContext.json.mock.calls[0][1]).toBe(200)
-  })
-
-  it('should return consistent packument for proxied packages with only required fields', async () => {
-    const { mockContext } = setupTest()
-
-    // Change request to fetch proxied package
-    mockContext.req.param = vi.fn((name) => {
-      if (name === 'pkg') {
-        return 'proxied-package'
-      }
-      return undefined
-    })
-
-    // Capture dist-tags for verification
-    let capturedTags = null
-    mockContext.db.upsertPackage = vi.fn(async (name, tags) => {
-      capturedTags = tags
-      return true
-    })
-
-    await getPackagePackument(mockContext)
-
-    // Verify response
-    expect(mockContext.json).toHaveBeenCalled()
-    const responseData = mockContext.json.mock.calls[0][0]
-
-    // Verify structure
-    expect(responseData).toHaveProperty('name', 'proxied-package')
-    expect(responseData).toHaveProperty('dist-tags')
-    expect(responseData).toHaveProperty('versions')
-    expect(responseData).toHaveProperty('time')
-
-    // Check that tags were properly stored
-    expect(capturedTags).toEqual({
-      latest: '2.0.0',
-      next: '2.1.0-rc.1'
-    })
-
-    // Verify no extra fields
-    expect(responseData).not.toHaveProperty('_id')
-    expect(responseData).not.toHaveProperty('_rev')
-    expect(responseData).not.toHaveProperty('_attachments')
-
-    // Verify versions exist
-    expect(Object.keys(responseData.versions)).toContain('2.0.0')
-    expect(Object.keys(responseData.versions)).toContain('2.1.0-rc.1')
-
-    // Check version format
-    const version = responseData.versions['2.0.0']
-    expect(version).toBeDefined()
-    expect(version).toHaveProperty('name', 'proxied-package')
-    expect(version).toHaveProperty('version', '2.0.0')
-    expect(version).not.toHaveProperty('_id')
-    expect(version).not.toHaveProperty('_npmUser')
-    expect(version).not.toHaveProperty('readme')
-
-    // Verify status
-    expect(mockContext.json.mock.calls[0][1]).toBe(200)
-  })
-
-  it('should handle background refresh while maintaining consistent response format', async () => {
-    const { mockContext } = setupTest()
-
-    // Setup stale timestamp
-    const oldDate = new Date()
-    oldDate.setDate(oldDate.getDate() - 10)
-
-    // Mock stale package data
-    mockContext.db.getPackage = vi.fn(async (name) => {
-      if (name === 'local-package') {
-        return {
-          name: 'local-package',
-          tags: { latest: '1.0.0', beta: '1.1.0-beta.1' },
-          lastUpdated: oldDate.toISOString()
-        }
-      }
-      return null
-    })
-
-    await getPackagePackument(mockContext)
-
-    // Verify background refresh was triggered
-    expect(mockContext.executionCtx.waitUntil).toHaveBeenCalled()
-
-    // Verify response
-    expect(mockContext.json).toHaveBeenCalled()
-    const responseData = mockContext.json.mock.calls[0][0]
-
-    // Verify structure
-    expect(responseData).toEqual(expect.objectContaining({
-      name: 'local-package',
-      'dist-tags': expect.any(Object),
-      versions: expect.any(Object),
-      time: expect.any(Object)
-    }))
-
-    // Verify status
-    expect(mockContext.json.mock.calls[0][1]).toBe(200)
-  })
-})

package/test/packument-version-range.test.js

@@ -1,144 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import * as semver from 'semver'
-
-// Mock semver to use actual implementation
-vi.mock('semver', async () => {
-  const actual = await vi.importActual('semver')
-  return {
-    ...actual
-  }
-})
-
-// Mock config
-vi.mock('../../config.js', () => ({
-  DOMAIN: 'https://registry.example.com',
-  PROXY: false // Disable proxy for these tests
-}))
-
-describe('Packument Version Range Filtering', () => {
-  // Test the versionRange filtering functionality directly
-  describe('Core semver filtering behavior', () => {
-
-    // Create a realistic set of package versions
-    const versions = [
-      '1.0.0', '1.0.1', '1.1.0', '1.2.0', '1.2.3',  // Major 1
-      '2.0.0', '2.0.1', '2.1.0',                    // Major 2
-      '3.0.0-beta.1', '3.0.0-beta.2',               // Pre-release versions
-    ]
-
-    // Function to simulate the filtering logic from our implementation
-    const filterVersionsByRange = (versions, range) => {
-      if (!semver.validRange(range)) {
-        throw new Error(`Invalid semver range: ${range}`)
-      }
-
-      return versions.filter(version => semver.satisfies(version, range))
-    }
-
-    it('should validate semver ranges correctly', () => {
-      // Valid ranges
-      expect(semver.validRange('1.x')).toBeTruthy()
-      expect(semver.validRange('^2.0.0')).toBeTruthy()
-      expect(semver.validRange('~2.0.0')).toBeTruthy()
-      expect(semver.validRange('>=1.2.0 <2.1.0')).toBeTruthy()
-      expect(semver.validRange('^3.0.0-0')).toBeTruthy()
-
-      // Invalid range
-      expect(semver.validRange('not-a-valid-range')).toBeNull()
-    })
-
-    it('should filter by major version (1.x)', () => {
-      const range = '1.x'
-      const filtered = filterVersionsByRange(versions, range)
-
-      // Should only include major 1 versions
-      const expected = ['1.0.0', '1.0.1', '1.1.0', '1.2.0', '1.2.3']
-      expect(filtered).toEqual(expected)
-      expect(filtered.length).toBe(5)
-
-      // Shouldn't include major 2 or 3
-      expect(filtered).not.toContain('2.0.0')
-      expect(filtered).not.toContain('3.0.0-beta.1')
-    })
-
-    it('should filter with caret range (^2.0.0)', () => {
-      const range = '^2.0.0'
-      const filtered = filterVersionsByRange(versions, range)
-
-      // Should include all 2.x versions
-      const expected = ['2.0.0', '2.0.1', '2.1.0']
-      expect(filtered).toEqual(expected)
-      expect(filtered.length).toBe(3)
-
-      // Shouldn't include major 1 or 3
-      expect(filtered).not.toContain('1.2.3')
-      expect(filtered).not.toContain('3.0.0-beta.1')
-    })
-
-    it('should filter with tilde range (~2.0.0)', () => {
-      const range = '~2.0.0'
-      const filtered = filterVersionsByRange(versions, range)
-
-      // Should only include patch versions of 2.0
-      const expected = ['2.0.0', '2.0.1']
-      expect(filtered).toEqual(expected)
-      expect(filtered.length).toBe(2)
-
-      // Shouldn't include minor versions
-      expect(filtered).not.toContain('2.1.0')
-    })
-
-    it('should filter with complex range (>=1.2.0 <2.1.0)', () => {
-      const range = '>=1.2.0 <2.1.0'
-      const filtered = filterVersionsByRange(versions, range)
-
-      // Should include specified range
-      const expected = ['1.2.0', '1.2.3', '2.0.0', '2.0.1']
-      expect(filtered).toEqual(expected)
-      expect(filtered.length).toBe(4)
-
-      // Verify boundaries are respected
-      expect(filtered).not.toContain('1.1.0')
-      expect(filtered).not.toContain('2.1.0')
-    })
-
-    it('should handle pre-release versions when explicitly included (^3.0.0-0)', () => {
-      const range = '^3.0.0-0'
-      const filtered = filterVersionsByRange(versions, range)
-
-      // Should include beta versions
-      const expected = ['3.0.0-beta.1', '3.0.0-beta.2']
-      expect(filtered).toEqual(expected)
-      expect(filtered.length).toBe(2)
-    })
-
-    it('should reject invalid semver ranges', () => {
-      const range = 'not-a-valid-range'
-      expect(() => filterVersionsByRange(versions, range)).toThrow('Invalid semver range')
-    })
-  })
-
-  // Test the API integration with minimal mocking
-  describe('API implementation integration', () => {
-    it('should correctly integrate with the API', () => {
-      // Verify that the actual API implementation would correctly:
-      // 1. Extract the versionRange query parameter
-      // 2. Validate it using semver.validRange
-      // 3. Filter versions using semver.satisfies
-
-      // Instead of trying to mock the entire system, we're just
-      // asserting here that the core semver functionality works
-      // as expected when integrated with our API filtering logic
-
-      const validRange = semver.validRange('^1.0.0')
-      expect(validRange).toBeTruthy()
-
-      const version = '1.2.3'
-      const matchesRange = semver.satisfies(version, '^1.0.0')
-      expect(matchesRange).toBe(true)
-
-      const doesntMatch = semver.satisfies('2.0.0', '^1.0.0')
-      expect(doesntMatch).toBe(false)
-    })
-  })
-})

package/test/performance.test.js

@@ -1,162 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { unstable_dev } from 'wrangler'
-
-describe('Performance Tests', () => {
-  let worker
-
-  beforeAll(async () => {
-    worker = await unstable_dev('src/index.js', {
-      experimental: { disableExperimentalWarning: true },
-      local: true,
-      port: 1338, // Use different port to avoid conflicts
-    })
-  })
-
-  afterAll(async () => {
-    await worker.stop()
-  })
-
-  async function measureRequestTime(url, expectJson = true) {
-    const start = Date.now()
-    const response = await fetch(url)
-    const end = Date.now()
-    const duration = end - start
-
-    let data = null
-    if (response.ok && expectJson) {
-      try {
-        data = await response.json()
-      } catch (e) {
-        // Handle non-JSON responses (like tarballs)
-        data = null
-      }
-    }
-
-    return {
-      duration,
-      ok: response.ok,
-      status: response.status,
-      data
-    }
-  }
-
-  it('should be faster than npm registry for packument requests', async () => {
-    const testPackage = 'lodash'
-
-    // Test npm registry directly
-    const npmResult = await measureRequestTime(`https://registry.npmjs.org/${testPackage}`)
-    console.log(`NPM registry time: ${npmResult.duration}ms`)
-
-    // Test our registry (first request - cache miss)
-    const ourFirstResult = await measureRequestTime(`http://localhost:1338/npm/${testPackage}`)
-    console.log(`Our registry (first): ${ourFirstResult.duration}ms`)
-
-    // Test our registry (second request - should be cached)
-    const ourSecondResult = await measureRequestTime(`http://localhost:1338/npm/${testPackage}`)
-    console.log(`Our registry (cached): ${ourSecondResult.duration}ms`)
-
-    expect(npmResult.ok).toBe(true)
-    expect(ourFirstResult.ok).toBe(true)
-    expect(ourSecondResult.ok).toBe(true)
-
-    // Second request should be faster than first (due to caching)
-    expect(ourSecondResult.duration).toBeLessThan(ourFirstResult.duration)
-
-    // Cached request should be faster than npm (relaxed expectation)
-    expect(ourSecondResult.duration).toBeLessThan(npmResult.duration * 2) // Allow up to 2x npm time
-  }, 30000)
-
-  it('should cache tarball requests effectively', async () => {
-    const testPackage = 'lodash'
-    const testVersion = '4.17.21'
-    const tarballUrl = `http://localhost:1338/npm/${testPackage}/-/${testPackage}-${testVersion}.tgz`
-
-    // First tarball request (don't expect JSON)
-    const firstRequest = await measureRequestTime(tarballUrl, false)
-    console.log(`Tarball (first): ${firstRequest.duration}ms`)
-
-    // Second tarball request (should be cached)
-    const secondRequest = await measureRequestTime(tarballUrl, false)
-    console.log(`Tarball (cached): ${secondRequest.duration}ms`)
-
-    expect(firstRequest.ok).toBe(true)
-    expect(secondRequest.ok).toBe(true)
-
-    // Second request should be reasonably fast (allow for network variance)
-    expect(secondRequest.duration).toBeLessThan(firstRequest.duration * 3) // Allow more variance for small requests
-  }, 30000)
-
-  it('should handle manifest requests efficiently', async () => {
-    const testPackage = 'express'
-    const testVersion = '4.18.2'
-    const manifestUrl = `http://localhost:1338/npm/${testPackage}/${testVersion}`
-
-    // First manifest request
-    const firstRequest = await measureRequestTime(manifestUrl)
-    console.log(`Manifest (first): ${firstRequest.duration}ms`)
-
-    // Second manifest request (should be cached)
-    const secondRequest = await measureRequestTime(manifestUrl)
-    console.log(`Manifest (cached): ${secondRequest.duration}ms`)
-
-    expect(firstRequest.ok).toBe(true)
-    expect(secondRequest.ok).toBe(true)
-
-    // Verify the manifest has rewritten tarball URLs to our domain
-    expect(secondRequest.data.dist.tarball).toContain('localhost')
-    expect(secondRequest.data.dist.tarball).toContain(testPackage)
-
-    // Second request should be faster or at least not much slower
-    expect(secondRequest.duration).toBeLessThan(firstRequest.duration * 1.5) // Allow some variance
-  }, 30000)
-
-  it('should demonstrate racing cache performance', async () => {
-    const testPackages = ['react', 'vue', 'angular']
-    const results = []
-
-    for (const pkg of testPackages) {
-      // Measure cold request (no cache)
-      const coldResult = await measureRequestTime(`http://localhost:1338/npm/${pkg}`)
-
-      // Measure warm request (potentially cached)
-      const warmResult = await measureRequestTime(`http://localhost:1338/npm/${pkg}`)
-
-      results.push({
-        package: pkg,
-        cold: coldResult.duration,
-        warm: warmResult.duration,
-        improvement: ((coldResult.duration - warmResult.duration) / coldResult.duration * 100).toFixed(1)
-      })
-
-      console.log(`${pkg}: Cold ${coldResult.duration}ms, Warm ${warmResult.duration}ms (${results[results.length-1].improvement}% faster)`)
-    }
-
-    // At least some packages should show improvement (or at least not be much worse)
-    const reasonableResults = results.filter(r => parseFloat(r.improvement) > -50) // Allow up to 50% slower due to racing
-    expect(reasonableResults.length).toBeGreaterThan(0)
-  }, 60000)
-
-  it('should handle high concurrency efficiently', async () => {
-    const testPackage = 'uuid'
-    const concurrency = 10
-
-    // Make concurrent requests
-    const promises = Array(concurrency).fill().map((_, i) =>
-      measureRequestTime(`http://localhost:1338/npm/${testPackage}?_t=${i}`)
-    )
-
-    const start = Date.now()
-    const results = await Promise.all(promises)
-    const totalTime = Date.now() - start
-
-    console.log(`${concurrency} concurrent requests completed in ${totalTime}ms`)
-    console.log(`Average per request: ${(totalTime / concurrency).toFixed(1)}ms`)
-
-    // All requests should succeed
-    expect(results.every(r => r.ok)).toBe(true)
-
-    // Concurrent requests shouldn't be much slower than sequential
-    const avgRequestTime = totalTime / concurrency
-    expect(avgRequestTime).toBeLessThan(5000) // Should average less than 5 seconds per request
-  }, 60000)
-})