@vltpkg/query 1.4.0 → 1.6.0

package/test/pseudo/helpers.ts

@@ -1,370 +0,0 @@
-import t from 'tap'
-import { asSecurityArchiveLike } from '@vltpkg/security-archive'
-import {
-  createSecuritySelectorFilter,
-  removeDanglingEdges,
-  removeNode,
-  removeQuotes,
-  removeEdge,
-  removeUnlinkedNodes,
-  clear,
-  assertSecurityArchive,
-} from '../../src/pseudo/helpers.ts'
-import {
-  getMissingNodeGraph,
-  getSimpleGraph,
-  getMultiWorkspaceGraph,
-} from '../fixtures/graph.ts'
-import type { ParserState } from '../../src/types.ts'
-import { joinDepIDTuple } from '@vltpkg/dep-id/browser'
-import { parse } from '../../src/parser.ts'
-
-t.test('removeDanglingEdges', async t => {
-  await t.test('graph with missing nodes', async t => {
-    const graph = getMissingNodeGraph()
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeDanglingEdges(state)
-
-    t.strictSame(
-      [...state.partial.edges],
-      [],
-      'should remove dangling edges',
-    )
-  })
-
-  await t.test('graph with no dangling edges', async t => {
-    const graph = getSimpleGraph()
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeDanglingEdges(state)
-
-    t.strictSame(
-      [...state.partial.edges],
-      [...graph.edges],
-      'should not remove any edges',
-    )
-  })
-})
-
-t.test('removeNode', async t => {
-  await t.test('remove a node with incoming edges', async t => {
-    const graph = getSimpleGraph()
-    const node = graph.nodes.get(
-      joinDepIDTuple(['registry', '', 'a@1.0.0']),
-    )!
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeNode(state, node)
-
-    for (const edge of partial.edges) {
-      if (edge.to === node) {
-        throw new Error('should have removed the incoming edge')
-      }
-    }
-    const expectedNodes = [...graph.nodes.values()].filter(
-      n => n !== node,
-    )
-    t.strictSame(
-      [...state.partial.nodes],
-      expectedNodes,
-      'should remove the node',
-    )
-  })
-
-  await t.test('remove a node with no incoming edges', async t => {
-    const graph = getMultiWorkspaceGraph()
-    const node = graph.nodes.get(joinDepIDTuple(['workspace', 'b']))!
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeNode(state, node)
-
-    const expectedNodes = [...graph.nodes.values()].filter(
-      n => n !== node,
-    )
-    t.strictSame(
-      [...state.partial.nodes],
-      expectedNodes,
-      'should remove the node',
-    )
-    t.strictSame(
-      [...state.partial.edges],
-      [...graph.edges],
-      'should not remove any edges',
-    )
-  })
-})
-
-t.test('removeQuotes', async t => {
-  t.equal(removeQuotes('""'), '', 'should remove quotes')
-  t.equal(removeQuotes('"a"'), 'a', 'should remove quotes')
-  t.equal(removeQuotes('a'), 'a', 'should not remove quotes')
-  t.equal(removeQuotes('1234'), '1234', 'should not remove quotes')
-})
-
-t.test('removeEdge', async t => {
-  await t.test('remove an edge and its outgoing node', async t => {
-    const graph = getSimpleGraph()
-    const edge = [...graph.edges].find(e => e.name === 'a')!
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeEdge(state, edge)
-
-    t.notOk(
-      [...state.partial.edges].includes(edge),
-      'should remove the edge',
-    )
-    t.notOk(
-      [...state.partial.nodes].includes(edge.to!),
-      'should remove the outgoing node',
-    )
-  })
-
-  await t.test('remove an edge with no outgoing node', async t => {
-    const graph = getMissingNodeGraph()
-    const edge = [...graph.edges].find(e => e.name === 'a')!
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeEdge(state, edge)
-
-    t.notOk(
-      [...state.partial.edges].includes(edge),
-      'should remove the edge',
-    )
-    t.strictSame(
-      [...state.partial.nodes],
-      [...graph.nodes.values()],
-      'should not modify nodes when edge has no outgoing node',
-    )
-  })
-})
-
-t.test('removeUnlinkedNodes', async t => {
-  await t.test('graph with unlinked nodes', async t => {
-    const graph = getMultiWorkspaceGraph()
-    // Get node b, which has no incoming edges in the multi-workspace graph
-    const nodeB = graph.nodes.get(joinDepIDTuple(['workspace', 'b']))!
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    removeUnlinkedNodes(state)
-
-    const expectedNodes = [...graph.nodes.values()].filter(
-      n => n !== nodeB && n.edgesIn.size > 0,
-    )
-    t.strictSame(
-      [...state.partial.nodes],
-      expectedNodes,
-      'should remove nodes with no incoming edges',
-    )
-  })
-
-  await t.test(
-    'graph with all nodes having incoming edges',
-    async t => {
-      const graph = getSimpleGraph()
-      // All nodes except main importer in simple graph have incoming edges
-      const partial = {
-        edges: new Set(graph.edges),
-        nodes: new Set(
-          [...graph.nodes.values()].filter(
-            n => n !== graph.mainImporter,
-          ),
-        ),
-      }
-      const state = { partial } as ParserState
-
-      removeUnlinkedNodes(state)
-
-      t.strictSame(
-        [...state.partial.nodes],
-        [...partial.nodes],
-        'should not remove any nodes when all have incoming edges',
-      )
-    },
-  )
-})
-
-t.test('clear', async t => {
-  await t.test('clears all nodes and edges', async t => {
-    const graph = getSimpleGraph()
-    const partial = {
-      edges: new Set(graph.edges),
-      nodes: new Set(graph.nodes.values()),
-    }
-    const state = { partial } as ParserState
-
-    // Verify the state has nodes and edges before clearing
-    t.ok(
-      state.partial.nodes.size > 0,
-      'state should have nodes before clearing',
-    )
-    t.ok(
-      state.partial.edges.size > 0,
-      'state should have edges before clearing',
-    )
-
-    // Call the clear function
-    const result = clear(state)
-
-    // Verify the nodes and edges are cleared
-    t.equal(state.partial.nodes.size, 0, 'should clear all nodes')
-    t.equal(state.partial.edges.size, 0, 'should clear all edges')
-
-    // Verify the function returns the state
-    t.equal(result, state, 'should return the state object')
-  })
-})
-
-t.test('assertSecurityArchive', async t => {
-  await t.test('with security archive present', async t => {
-    const state = {
-      securityArchive: asSecurityArchiveLike(new Map()),
-    } as ParserState
-
-    // Should not throw when security archive is present
-    t.doesNotThrow(
-      () => assertSecurityArchive(state, 'test'),
-      'should not throw when security archive is present',
-    )
-  })
-
-  await t.test('with security archive missing', async t => {
-    const state = {
-      securityArchive: undefined,
-    } as ParserState
-
-    // Should throw when security archive is missing
-    t.throws(
-      () => assertSecurityArchive(state, 'test'),
-      { message: /Missing security archive/ },
-      'should throw when security archive is missing',
-    )
-  })
-})
-
-t.test('selects packages with an unmaintained alert', async t => {
-  const getState = (query: string, graph = getSimpleGraph()) => {
-    const ast = parse(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,
-      securityArchive: asSecurityArchiveLike(
-        new Map([
-          [
-            joinDepIDTuple(['registry', '', 'e@1.0.0']),
-            { alerts: [{ type: 'unmaintained' }] },
-          ],
-        ]),
-      ),
-      importers: new Set(graph.importers),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  const unmaintained = createSecuritySelectorFilter(
-    'unmaintained',
-    'unmaintained',
-  )
-  await t.test(
-    'filter out any node that does not have the alert',
-    async t => {
-      const res = await unmaintained(getState(':unmaintained'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['e'],
-        'should select only unmaintained packages',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-})
-
-t.test('missing security archive', async t => {
-  const getState = (query: string) => {
-    const ast = parse(query)
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      partial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      cancellable: async () => {},
-      walk: async i => i,
-      securityArchive: undefined,
-      importers: new Set(),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  const unmaintained = createSecuritySelectorFilter(
-    'unmaintained',
-    'unmaintained',
-  )
-  await t.rejects(
-    unmaintained(getState(':unmaintained')),
-    { message: /Missing security archive/ },
-    'should throw an error',
-  )
-})

package/test/pseudo/host-context.ts

@@ -1,276 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import { asSecurityArchiveLike } from '@vltpkg/security-archive'
-import type {
-  HostContextsMap,
-  ParserState,
-  HostContextsMapResult,
-} from '../../src/types.ts'
-import type { GraphLike, EdgeLike } from '@vltpkg/types'
-import { hostContext } from '../../src/pseudo/host.ts'
-import {
-  getSimpleGraph,
-  getMultiWorkspaceGraph,
-} from '../fixtures/graph.ts'
-
-t.test('host selector', async t => {
-  // Helper function to convert GraphLike objects to HostContextsMapResult
-  const graphsToHostContextResult = (
-    graphs: GraphLike[],
-  ): HostContextsMapResult => {
-    const allEdges: EdgeLike[] = []
-    const allNodes = []
-
-    for (const graph of graphs) {
-      allEdges.push(...graph.edges.values())
-      allNodes.push(...graph.nodes.values())
-    }
-
-    return {
-      initialEdges: allEdges,
-      initialNodes: allNodes,
-      edges: allEdges,
-      nodes: allNodes,
-      securityArchive: asSecurityArchiveLike(new Map()),
-    }
-  }
-
-  const getState = (
-    query: string,
-    graph = getSimpleGraph(),
-    hostContexts?: HostContextsMap,
-  ) => {
-    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(),
-      },
-      hostContexts,
-      importers: new Set(graph.importers),
-      cancellable: async () => {},
-      walk: async i => i,
-      retries: 0,
-      securityArchive: undefined,
-      signal: new AbortController().signal,
-      scopeIDs: [],
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test('switches to graphs from host context', async t => {
-    const testGraph1 = getSimpleGraph()
-    const testGraph2 = getMultiWorkspaceGraph()
-
-    const hostContexts: HostContextsMap = new Map()
-    hostContexts.set('test-context', async () =>
-      graphsToHostContextResult([testGraph2]),
-    )
-
-    const state = getState(
-      ':host(test-context)',
-      testGraph1,
-      hostContexts,
-    )
-    const res = await hostContext(state)
-
-    // Should have switched to nodes/edges from testGraph2
-    t.equal(res.partial.nodes.size, testGraph2.nodes.size)
-    t.equal(res.partial.edges.size, testGraph2.edges.size)
-
-    // Verify the nodes are from testGraph2
-    const nodeNames = [...res.partial.nodes].map(n => n.name).sort()
-    const expectedNames = [...testGraph2.nodes.values()]
-      .map(n => n.name)
-      .sort()
-    t.same(nodeNames, expectedNames)
-  })
-
-  await t.test(
-    'combines multiple graphs from host context',
-    async t => {
-      const graph1: GraphLike = getSimpleGraph()
-      const graph2: GraphLike = getMultiWorkspaceGraph()
-
-      const hostContexts: HostContextsMap = new Map()
-      hostContexts.set('multi-context', async () =>
-        graphsToHostContextResult([graph1, graph2]),
-      )
-
-      const state = getState(
-        ':host(multi-context)',
-        getSimpleGraph(),
-        hostContexts,
-      )
-      const res = await hostContext(state)
-
-      // Should have combined nodes/edges from both graphs
-      const expectedNodeCount = graph1.nodes.size + graph2.nodes.size
-      const expectedEdgeCount = graph1.edges.size + graph2.edges.size
-
-      t.equal(res.partial.nodes.size, expectedNodeCount)
-      t.equal(res.partial.edges.size, expectedEdgeCount)
-    },
-  )
-
-  await t.test('handles async host context functions', async t => {
-    const testGraph = getMultiWorkspaceGraph()
-
-    const hostContexts: HostContextsMap = new Map()
-    hostContexts.set('async-context', async () => {
-      // Simulate async operation
-      await new Promise(resolve => setTimeout(resolve, 10))
-      return graphsToHostContextResult([testGraph])
-    })
-
-    const state = getState(
-      ':host(async-context)',
-      getSimpleGraph(),
-      hostContexts,
-    )
-    const res = await hostContext(state)
-
-    t.equal(res.partial.nodes.size, testGraph.nodes.size)
-    t.equal(res.partial.edges.size, testGraph.edges.size)
-  })
-
-  await t.test(
-    'throws error when no host contexts available',
-    async t => {
-      const state = getState(':host(test)')
-
-      await t.rejects(
-        hostContext(state),
-        /No host contexts available for :host selector/,
-        'should throw when hostContexts is undefined',
-      )
-    },
-  )
-
-  await t.test('throws error for unknown host context', async t => {
-    const hostContexts: HostContextsMap = new Map()
-    hostContexts.set('known-context', async () =>
-      graphsToHostContextResult([]),
-    )
-
-    const state = getState(
-      ':host(unknown)',
-      getSimpleGraph(),
-      hostContexts,
-    )
-
-    await t.rejects(
-      hostContext(state),
-      /Unknown host context: unknown/,
-      'should throw for unknown context key',
-    )
-  })
-
-  await t.test('handles empty context key', async t => {
-    const hostContexts: HostContextsMap = new Map()
-    const state = getState(
-      ':host("")',
-      getSimpleGraph(),
-      hostContexts,
-    )
-
-    await t.rejects(
-      hostContext(state),
-      /Failed to parse :host selector/,
-      'should throw for empty context key',
-    )
-  })
-
-  await t.test('handles unquoted context key', async t => {
-    const testGraph = getMultiWorkspaceGraph()
-    const hostContexts: HostContextsMap = new Map()
-    hostContexts.set('unquoted', async () =>
-      graphsToHostContextResult([testGraph]),
-    )
-
-    // Create state with unquoted parameter
-    const ast = postcssSelectorParser().astSync(':host(unquoted)')
-    const current = ast.first.first
-    const state: ParserState = {
-      comment: '',
-      current,
-      initial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      partial: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      collect: {
-        edges: new Set(),
-        nodes: new Set(),
-      },
-      importers: new Set(),
-      cancellable: async () => {},
-      walk: async i => i,
-      retries: 0,
-      securityArchive: undefined,
-      signal: new AbortController().signal,
-      scopeIDs: [],
-      specificity: { idCounter: 0, commonCounter: 0 },
-      hostContexts,
-    }
-
-    const res = await hostContext(state)
-    t.equal(res.partial.nodes.size, testGraph.nodes.size)
-  })
-
-  await t.test(
-    'clears existing nodes and edges before switching',
-    async t => {
-      const originalGraph = getSimpleGraph()
-      const newGraph = getMultiWorkspaceGraph()
-
-      const hostContexts: HostContextsMap = new Map()
-      hostContexts.set('replace-context', async () =>
-        graphsToHostContextResult([newGraph]),
-      )
-
-      const state = getState(
-        ':host(replace-context)',
-        originalGraph,
-        hostContexts,
-      )
-
-      // Verify initial state has original graph data
-      t.equal(state.partial.nodes.size, originalGraph.nodes.size)
-      t.equal(state.partial.edges.size, originalGraph.edges.size)
-
-      const res = await hostContext(state)
-
-      // Verify state now only has new graph data
-      t.equal(res.partial.nodes.size, newGraph.nodes.size)
-      t.equal(res.partial.edges.size, newGraph.edges.size)
-
-      // Verify that all nodes in result are from the new graph
-      for (const node of res.partial.nodes) {
-        const newGraphNode = newGraph.nodes.get(node.id)
-        if (newGraphNode) {
-          t.equal(
-            node.name,
-            newGraphNode.name,
-            'node should match new graph node',
-          )
-        }
-      }
-    },
-  )
-})