@vltpkg/query 1.0.0-rc.9 → 1.0.1

package/test/pseudo/peer.ts

@@ -0,0 +1,101 @@
+import t from 'tap'
+import { pseudo } from '../../src/pseudo.ts'
+import {
+  selectorFixture,
+  copyGraphSelectionState,
+} from '../fixtures/selector.ts'
+import { getSimpleGraph } from '../fixtures/graph.ts'
+import type { TestCase } from '../fixtures/types.ts'
+import type { GraphSelectionState } from '../../src/types.ts'
+
+const testPseudo = selectorFixture(pseudo)
+
+t.test(':peer pseudo-selector', async t => {
+  // Get a simple graph for testing
+  const simpleGraph = getSimpleGraph()
+
+  // Create a peer dependency edge for testing
+  // Find an existing edge and change its type to 'peer'
+  for (const edge of simpleGraph.edges) {
+    if (edge.name === 'c') {
+      edge.type = 'peer'
+      break
+    }
+  }
+
+  // Get the full selection state
+  const all = {
+    edges: new Set(simpleGraph.edges),
+    nodes: new Set(simpleGraph.nodes.values()),
+  }
+
+  // Create an empty selection state
+  const empty: GraphSelectionState = {
+    edges: new Set(),
+    nodes: new Set(),
+  }
+
+  // Run tests in the same pattern as the main pseudo.ts tests
+  const queryToExpected = new Set<TestCase>([
+    [':peer', all, ['c']], // Should return nodes with peer dependency edges
+    [':peer', empty, []], // Empty input should return empty output
+  ])
+
+  const initial = copyGraphSelectionState(all)
+  for (const [query, partial, expected] of queryToExpected) {
+    const result = await testPseudo(
+      query,
+      initial,
+      copyGraphSelectionState(partial),
+    )
+
+    t.strictSame(
+      result.nodes.map(i => i.name),
+      expected,
+      `query > "${query}"`,
+    )
+
+    // Verify all edges are peer dependencies
+    const edgeArray = [...result.edges]
+    if (edgeArray.length > 0) {
+      for (const edge of edgeArray) {
+        t.ok(
+          edge.type === 'peer' || edge.type === 'peerOptional',
+          `edge ${edge.name} should have type 'peer' or 'peerOptional'`,
+        )
+      }
+    }
+  }
+
+  // Test peerOptional type
+  t.test('handles peerOptional dependencies', async t => {
+    // Change an edge to peerOptional for testing
+    for (const edge of simpleGraph.edges) {
+      if (edge.name === 'd') {
+        edge.type = 'peerOptional'
+        break
+      }
+    }
+
+    // Run the test
+    const result = await testPseudo(
+      ':peer',
+      initial,
+      copyGraphSelectionState(all),
+    )
+
+    // Result should include both peer and peerOptional dependencies
+    const nodeArray = [...result.nodes]
+    t.ok(
+      nodeArray.length >= 2,
+      'Result should include both peer and peerOptional dependencies',
+    )
+
+    // Verify that our peerOptional dependency is included
+    const nodeNames = nodeArray.map(n => n.name)
+    t.ok(
+      nodeNames.includes('d'),
+      'Result should include the peerOptional dependency',
+    )
+  })
+})

package/test/pseudo/prerelease.ts

@@ -0,0 +1,279 @@
+import t from 'tap'
+import postcssSelectorParser from 'postcss-selector-parser'
+import type { ParserState } from '../../src/types.ts'
+import { prerelease } from '../../src/pseudo/prerelease.ts'
+import { parse } from '@vltpkg/semver'
+import {
+  getSemverRichGraph,
+  getSimpleGraph,
+  newGraph,
+  newNode,
+} from '../fixtures/graph.ts'
+
+t.test(':prerelease pseudo-selector', async t => {
+  const getState = (query: string, graph = getSemverRichGraph()) => {
+    const ast = postcssSelectorParser().astSync(query)
+    const current = ast.first.first
+    const state: ParserState = {
+      comment: '',
+      current,
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      cancellable: async () => {},
+      walk: async i => i,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    return state
+  }
+
+  await t.test(
+    'selects only nodes with prerelease versions',
+    async t => {
+      const res = await prerelease(getState(':prerelease'))
+
+      // Should only select nodes with prerelease versions
+      const nodeNames = [...res.partial.nodes].map(n => n.name).sort()
+      const nodeVersions = [...res.partial.nodes]
+        .map(n => n.version)
+        .sort()
+
+      t.strictSame(
+        nodeNames,
+        ['e', 'g'],
+        'should select only nodes with prerelease versions',
+      )
+
+      t.strictSame(
+        nodeVersions,
+        ['1.2.3-rc.1+rev.2', '1.3.4-beta.1'],
+        'should select correct prerelease versions',
+      )
+
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => ({
+          name: n.name,
+          version: n.version,
+        })),
+        edges: [...res.partial.edges].map(e => e.name),
+      })
+    },
+  )
+
+  await t.test('excludes non-prerelease versions', async t => {
+    const res = await prerelease(getState(':prerelease'))
+
+    // Verify that only prerelease versions remain
+    for (const node of res.partial.nodes) {
+      const version = node.manifest?.version
+      if (version) {
+        const parsed = parse(version)
+        t.ok(
+          parsed?.prerelease?.length,
+          `${node.name}@${version} should have prerelease identifiers`,
+        )
+      }
+    }
+
+    t.matchSnapshot([...res.partial.nodes].map(n => n.version).sort())
+  })
+
+  await t.test('handles nodes without version', async t => {
+    const graph = newGraph('test-project')
+    const addNode = newNode(graph)
+
+    // Create a node without version
+    const nodeWithoutVersion = addNode('no-version', '1.0.0')
+    nodeWithoutVersion.manifest = { name: 'no-version' } // No version field
+    graph.nodes.set(nodeWithoutVersion.id, nodeWithoutVersion)
+
+    const res = await prerelease(getState(':prerelease', graph))
+
+    t.strictSame(
+      [...res.partial.nodes].length,
+      0,
+      'should exclude all nodes when none have prerelease versions',
+    )
+
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => ({
+        name: n.name,
+        version: n.version,
+      })),
+    })
+  })
+
+  await t.test('handles nodes with invalid semver', async t => {
+    const graph = newGraph('test-project')
+    const addNode = newNode(graph)
+
+    // Create a node with invalid semver
+    const nodeWithInvalidSemver = addNode('invalid-semver', '1.0.0')
+    nodeWithInvalidSemver.version = 'not-a-semver'
+    nodeWithInvalidSemver.manifest = {
+      name: 'invalid-semver',
+      version: 'not-a-semver',
+    }
+    graph.nodes.set(nodeWithInvalidSemver.id, nodeWithInvalidSemver)
+
+    const res = await prerelease(getState(':prerelease', graph))
+
+    t.strictSame(
+      [...res.partial.nodes].length,
+      0,
+      'should exclude all nodes when none have valid prerelease versions',
+    )
+
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => ({
+        name: n.name,
+        version: n.version,
+      })),
+    })
+  })
+
+  await t.test('handles various prerelease formats', async t => {
+    const graph = newGraph('prerelease-test')
+    const addNode = newNode(graph)
+
+    // Create nodes with various prerelease formats
+    const testCases = [
+      { name: 'canary', version: '19.2.0-canary-fa3feba6-20250623' },
+      { name: 'beta', version: '1.0.0-beta.0' },
+      { name: 'alpha', version: '2.1.0-alpha.1' },
+      { name: 'rc', version: '3.0.0-rc.2' },
+      { name: 'dev', version: '0.0.0-16' },
+      { name: 'next', version: '1.5.0-next.1' },
+      { name: 'snapshot', version: '2.0.0-snapshot.20231201' },
+      { name: 'build-meta', version: '1.2.3-alpha.1+build.123' },
+      { name: 'stable', version: '1.0.0' }, // This should be filtered out
+      { name: 'another-stable', version: '2.5.3' }, // This should be filtered out
+    ]
+
+    for (const testCase of testCases) {
+      const node = addNode(testCase.name, testCase.version)
+      node.version = testCase.version
+      node.manifest = {
+        name: testCase.name,
+        version: testCase.version,
+      }
+      graph.nodes.set(node.id, node)
+    }
+
+    const res = await prerelease(getState(':prerelease', graph))
+
+    const selectedNodes = [...res.partial.nodes]
+      .map(n => ({ name: n.name, version: n.version }))
+      .sort((a, b) => (a.name || '').localeCompare(b.name || ''))
+
+    // Should select all prerelease versions but exclude stable ones
+    const expectedNodes = testCases
+      .filter(tc => tc.version.includes('-'))
+      .map(tc => ({ name: tc.name, version: tc.version }))
+      .sort((a, b) => a.name.localeCompare(b.name))
+
+    t.strictSame(
+      selectedNodes,
+      expectedNodes,
+      'should select all prerelease versions and exclude stable ones',
+    )
+
+    t.matchSnapshot({
+      selected: selectedNodes,
+      total: testCases.length,
+    })
+  })
+
+  await t.test('removes dangling edges properly', async t => {
+    const graph = getSemverRichGraph()
+    const initialEdgeCount = graph.edges.size
+
+    const res = await prerelease(getState(':prerelease', graph))
+
+    // Check that dangling edges were removed
+    const remainingEdges = [...res.partial.edges]
+
+    t.ok(
+      remainingEdges.length <= initialEdgeCount,
+      'should have same or fewer edges after filtering',
+    )
+
+    // Verify all remaining edges connect to nodes that remain
+    for (const edge of remainingEdges) {
+      if (edge.to) {
+        t.ok(
+          res.partial.nodes.has(edge.to),
+          `edge ${edge.name} should have valid to node`,
+        )
+      }
+    }
+
+    t.matchSnapshot({
+      remainingEdges: remainingEdges.length,
+      initialEdges: initialEdgeCount,
+      edgeNames: remainingEdges.map(e => e.name).sort(),
+    })
+  })
+
+  await t.test('works with empty graph', async t => {
+    const emptyGraph = newGraph('empty-test')
+    // Remove all nodes except root
+    emptyGraph.nodes.clear()
+    emptyGraph.edges.clear()
+    emptyGraph.nodes.set(
+      emptyGraph.mainImporter.id,
+      emptyGraph.mainImporter,
+    )
+
+    const res = await prerelease(getState(':prerelease', emptyGraph))
+
+    t.strictSame(
+      [...res.partial.nodes].length,
+      0,
+      'should have no nodes when root has no prerelease version',
+    )
+
+    t.strictSame(
+      [...res.partial.edges].length,
+      0,
+      'should have no edges',
+    )
+  })
+
+  await t.test(
+    'works with simple graph (no prereleases)',
+    async t => {
+      const simpleGraph = getSimpleGraph()
+      const res = await prerelease(
+        getState(':prerelease', simpleGraph),
+      )
+
+      // Simple graph has no prerelease versions
+      t.strictSame(
+        [...res.partial.nodes].length,
+        0,
+        'should have no nodes when no prereleases exist',
+      )
+
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => ({
+          name: n.name,
+          version: n.version,
+        })),
+      })
+    },
+  )
+})

package/test/pseudo/private.ts

@@ -0,0 +1,108 @@
+import t from 'tap'
+import postcssSelectorParser from 'postcss-selector-parser'
+import type { ParserState } from '../../src/types.ts'
+import { privateParser } from '../../src/pseudo/private.ts'
+import {
+  getSimpleGraph,
+  getSingleWorkspaceGraph,
+  getCycleGraph,
+} from '../fixtures/graph.ts'
+
+t.test('selects packages with private flag', async t => {
+  const getState = (query: string, graph = getSimpleGraph()) => {
+    const ast = postcssSelectorParser().astSync(query)
+    const current = ast.first.first
+    const state: ParserState = {
+      comment: '',
+      current,
+      initial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      partial: {
+        edges: new Set(graph.edges.values()),
+        nodes: new Set(graph.nodes.values()),
+      },
+      collect: {
+        edges: new Set(),
+        nodes: new Set(),
+      },
+      cancellable: async () => {},
+      walk: async i => i,
+      retries: 0,
+      securityArchive: undefined,
+      importers: new Set(graph.importers),
+      signal: new AbortController().signal,
+      specificity: { idCounter: 0, commonCounter: 0 },
+    }
+    return state
+  }
+
+  await t.test(
+    'selects nodes with private flag in simple graph',
+    async t => {
+      // Based on the getSimpleGraph fixture, only the 'd' package has private: true
+      const res = await privateParser(getState(':private'))
+      t.strictSame(
+        [...res.partial.nodes].map(n => n.name),
+        ['d'],
+        'should select only packages with private flag set to true',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name).sort(),
+        edges: [...res.partial.edges].map(e => e.name).sort(),
+      })
+    },
+  )
+
+  await t.test(
+    'selects no nodes with private flag in workspace graph',
+    async t => {
+      // In getSingleWorkspaceGraph, no nodes have private flag
+      const wsGraph = getSingleWorkspaceGraph()
+      const res = await privateParser(getState(':private', wsGraph))
+      t.strictSame(
+        [...res.partial.nodes].map(n => n.name),
+        [],
+        'should not select any nodes in workspace graph as none have private flag',
+      )
+      t.matchSnapshot({
+        nodes: [...res.partial.nodes].map(n => n.name).sort(),
+        edges: [...res.partial.edges].map(e => e.name).sort(),
+      })
+    },
+  )
+
+  await t.test('selects no nodes in cycle graph', async t => {
+    // In getCycleGraph, no nodes have private flag
+    const cycleGraph = getCycleGraph()
+    const res = await privateParser(getState(':private', cycleGraph))
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      [],
+      'should not select any packages in a cycle graph as none have private flag',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+
+  await t.test('handles an empty partial state', async t => {
+    // Create a state with empty partial nodes
+    const state = getState(':private')
+    state.partial.nodes.clear()
+    state.partial.edges.clear()
+
+    const res = await privateParser(state)
+    t.strictSame(
+      [...res.partial.nodes].map(n => n.name),
+      [],
+      'should return empty array when starting with empty partial state',
+    )
+    t.matchSnapshot({
+      nodes: [...res.partial.nodes].map(n => n.name),
+      edges: [...res.partial.edges].map(e => e.name),
+    })
+  })
+})

package/test/pseudo/prod.ts

@@ -0,0 +1,61 @@
+import t from 'tap'
+import { pseudo } from '../../src/pseudo.ts'
+import {
+  selectorFixture,
+  copyGraphSelectionState,
+} from '../fixtures/selector.ts'
+import { getSimpleGraph } from '../fixtures/graph.ts'
+import type { TestCase } from '../fixtures/types.ts'
+import type { GraphSelectionState } from '../../src/types.ts'
+
+const testPseudo = selectorFixture(pseudo)
+
+t.test(':prod pseudo-selector', async t => {
+  // Get a simple graph for testing
+  const simpleGraph = getSimpleGraph()
+
+  // Get the full selection state
+  const all = {
+    edges: new Set(simpleGraph.edges),
+    nodes: new Set(simpleGraph.nodes.values()),
+  }
+
+  // Create an empty selection state
+  const empty: GraphSelectionState = {
+    edges: new Set(),
+    nodes: new Set(),
+  }
+
+  // Run tests in the same pattern as the main pseudo.ts tests
+  const queryToExpected = new Set<TestCase>([
+    [':prod', all, ['a', 'c', 'd', 'e']], // Should return nodes with prod edges
+    [':prod', empty, []], // Empty input should return empty output
+  ])
+
+  const initial = copyGraphSelectionState(all)
+  for (const [query, partial, expected] of queryToExpected) {
+    const result = await testPseudo(
+      query,
+      initial,
+      copyGraphSelectionState(partial),
+    )
+
+    t.strictSame(
+      result.nodes.map(i => i.name),
+      expected,
+      `query > "${query}"`,
+    )
+
+    // Verify all edges are of type 'prod'
+    const edgeArray = [...result.edges]
+    if (edgeArray.length > 0) {
+      for (const edge of edgeArray) {
+        t.equal(
+          edge.type,
+          'prod',
+          `edge ${edge.name} should be of type 'prod'`,
+        )
+      }
+    }
+  }
+})