@vltpkg/query 1.5.0 → 1.6.1

package/test/pseudo/hostname.ts

@@ -1,314 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import type { ParserState } from '../../src/types.ts'
-import { hostname } from '../../src/pseudo/hostname.ts'
-import {
-  getSimpleGraph,
-  getAliasedGraph,
-  getGitGraph,
-  getRemoteGraph,
-  getLinkedGraph,
-  getCustomGitHostGraph,
-  getHttpsGitGraph,
-  getBrokenGitGraph,
-  getUnknownRegistryGraph,
-} from '../fixtures/graph.ts'
-
-t.test('selects nodes by hostname', 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(
-    'matches default registry deps by hostname',
-    async t => {
-      const res = await hostname(
-        getState(':hostname("registry.npmjs.org")'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a', 'b', 'c', 'd', 'e', 'f'],
-        'should match all default registry packages',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'matches custom registry deps by hostname',
-    async t => {
-      const graph = getAliasedGraph()
-      const res = await hostname(
-        getState(':hostname("example.com")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['c'],
-        'should match only custom registry packages',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test('matches github git deps by hostname', async t => {
-    const graph = getGitGraph()
-    const res = await hostname(
-      getState(':hostname("github.com")', graph),
-    )
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name).sort(),
-      ['a'],
-      'should match only github deps',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name).sort(),
-      edges: [...res.partial.edges].map(e => e.name).sort(),
-    })
-  })
-
-  await t.test('matches gitlab git deps by hostname', async t => {
-    const graph = getGitGraph()
-    const res = await hostname(
-      getState(':hostname("gitlab.com")', graph),
-    )
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name).sort(),
-      ['b'],
-      'should match only gitlab deps',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name).sort(),
-      edges: [...res.partial.edges].map(e => e.name).sort(),
-    })
-  })
-
-  await t.test(
-    'matches git deps with full URL by hostname',
-    async t => {
-      const graph = getGitGraph()
-      const res = await hostname(
-        getState(':hostname("custom-git.example.com")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['c'],
-        'should match git dep with full URL',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test('matches remote deps by hostname', async t => {
-    const graph = getRemoteGraph()
-    const res = await hostname(
-      getState(':hostname("cdn.example.com")', graph),
-    )
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name).sort(),
-      ['a'],
-      'should match remote dep by hostname',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name).sort(),
-      edges: [...res.partial.edges].map(e => e.name).sort(),
-    })
-  })
-
-  await t.test(
-    'excludes file deps from hostname matching',
-    async t => {
-      const graph = getLinkedGraph()
-      const res = await hostname(
-        getState(':hostname("registry.npmjs.org")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['b'],
-        'should exclude file deps and only match registry dep',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'returns empty when hostname does not match',
-    async t => {
-      const res = await hostname(
-        getState(':hostname("nonexistent.com")'),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        [],
-        'should return no nodes for nonexistent hostname',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test(
-    'falls back to default registry for unknown registry name',
-    async t => {
-      const graph = getUnknownRegistryGraph()
-      const res = await hostname(
-        getState(':hostname("registry.npmjs.org")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a'],
-        'should fall back to default registry hostname',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'matches custom named git host via template URL',
-    async t => {
-      const graph = getCustomGitHostGraph()
-      const res = await hostname(
-        getState(':hostname("myserver.example.com")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a'],
-        'should match custom git host via template URL parsing',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'matches git dep with plain https URL remote',
-    async t => {
-      const graph = getHttpsGitGraph()
-      const res = await hostname(
-        getState(':hostname("git.example.org")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a'],
-        'should match git dep with plain https URL',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'excludes git deps with unparseable remote URLs',
-    async t => {
-      const graph = getBrokenGitGraph()
-      const res = await hostname(
-        getState(':hostname("anything.com")', graph),
-      )
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        [],
-        'should not match any nodes with broken git URLs',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test('throws on invalid selector', async t => {
-    const ast = postcssSelectorParser().astSync(':hostname')
-    const current = ast.first.first
-    const graph = getSimpleGraph()
-    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 },
-    }
-    await t.rejects(
-      hostname(state),
-      { message: /Failed to parse :hostname selector/ },
-      'should throw an error for invalid selector',
-    )
-  })
-
-  await t.test('handles empty partial state', async t => {
-    const state = getState(':hostname("registry.npmjs.org")')
-    state.partial.nodes.clear()
-    state.partial.edges.clear()
-
-    const res = await hostname(state)
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      [],
-      'should return empty when partial state is empty',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-})

package/test/pseudo/license.ts

@@ -1,265 +0,0 @@
-import t from 'tap'
-import { joinDepIDTuple } from '@vltpkg/dep-id'
-import { asSecurityArchiveLike } from '@vltpkg/security-archive'
-import { getSimpleGraph } from '../fixtures/graph.ts'
-import type { ParserState } from '../../src/types.ts'
-import { parse } from '../../src/parser.ts'
-import {
-  license,
-  isLicenseKind,
-  asLicenseKind,
-} from '../../src/pseudo/license.ts'
-
-t.test('selects packages with a specific license kind', 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,
-      retries: 0,
-      securityArchive: asSecurityArchiveLike(
-        new Map([
-          [
-            joinDepIDTuple(['registry', '', 'e@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'e@1.0.0']),
-              alerts: [{ type: 'explicitlyUnlicensedItem' }],
-            },
-          ],
-          [
-            joinDepIDTuple(['registry', '', 'f@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'f@1.0.0']),
-              alerts: [{ type: 'miscLicenseIssues' }],
-            },
-          ],
-        ]),
-      ),
-      importers: new Set(graph.importers),
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.test(
-    'filter out any node that does not have the license',
-    async t => {
-      const res = await license(getState(':license("unlicensed")'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name),
-        ['e'],
-        'should select only packages with the specified license',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name),
-        edges: [...res.partial.edges].map(e => e.name),
-      })
-    },
-  )
-
-  await t.test('filter out using unquoted param', async t => {
-    const res = await license(getState(':license(misc)'))
-    t.strictSame(
-      [...res.partial.nodes].map(n => n.name),
-      ['f'],
-      'should select only packages with the specified license',
-    )
-    t.matchSnapshot({
-      nodes: [...res.partial.nodes].map(n => n.name),
-      edges: [...res.partial.edges].map(e => e.name),
-    })
-  })
-
-  await t.test('pseudo state form works', async t => {
-    // :license without parameters should now work as pseudo state
-    const result = await license(getState(':license'))
-    t.ok(result, 'should not throw an error for pseudo state form')
-  })
-})
-
-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,
-      retries: 0,
-      securityArchive: undefined,
-      importers: new Set(),
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  await t.rejects(
-    license(getState(':license(unlicensed)')),
-    { message: /Missing security archive/ },
-    'should throw an error',
-  )
-})
-
-t.test('isLicenseKind', async t => {
-  t.ok(
-    isLicenseKind('unlicensed'),
-    'should return true for valid license kinds',
-  )
-  t.notOk(
-    isLicenseKind('invalid'),
-    'should return false for invalid license kinds',
-  )
-})
-
-t.test('asLicenseKind', async t => {
-  t.equal(
-    asLicenseKind('unlicensed'),
-    'unlicensed',
-    'should return the license kind',
-  )
-  t.throws(
-    () => asLicenseKind('invalid'),
-    { message: /Expected a valid license kind/ },
-    'should throw an error for invalid license kinds',
-  )
-})
-
-t.test('pseudo state form - :license without parameters', async t => {
-  const getState = (graph = getSimpleGraph()) => {
-    const ast = parse(':license')
-    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']),
-            {
-              id: joinDepIDTuple(['registry', '', 'e@1.0.0']),
-              alerts: [{ type: 'explicitlyUnlicensedItem' }],
-            },
-          ],
-          [
-            joinDepIDTuple(['registry', '', 'f@1.0.0']),
-            {
-              id: joinDepIDTuple(['registry', '', 'f@1.0.0']),
-              alerts: [{ type: 'noLicenseFound' }],
-            },
-          ],
-        ]),
-      ),
-      importers: new Set(graph.importers),
-      retries: 0,
-      signal: new AbortController().signal,
-      specificity: { idCounter: 0, commonCounter: 0 },
-    }
-    return state
-  }
-
-  const state = getState()
-  const result = await license(state)
-  t.matchSnapshot(
-    {
-      nodes: [...result.partial.nodes].map(n => n.id),
-      edges: [...result.partial.edges].map(
-        e => `${e.from.id}->${e.to?.id}`,
-      ),
-    },
-    'should match packages with any license defined (not none)',
-  )
-})
-
-t.test('error handling for non-query node errors', async t => {
-  // Create a state that will trigger a non-"Expected a query node" error
-  // by providing malformed AST structure that causes a different parsing error
-  const ast = parse(':license(invalid)')
-  const current = ast.first.first
-
-  // Create a corrupted current node that will cause asPostcssNodeWithChildren to fail
-  // with a different error than "Expected a query node"
-  const corruptedCurrent = {
-    ...current,
-    nodes: [
-      {
-        type: 'function',
-        value: 'license',
-        nodes: null, // This will cause asPostcssNodeWithChildren to fail differently
-      },
-    ],
-  }
-
-  const state: ParserState = {
-    comment: '',
-    current: corruptedCurrent as any,
-    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: asSecurityArchiveLike(new Map()),
-    importers: new Set(),
-    retries: 0,
-    signal: new AbortController().signal,
-    specificity: { idCounter: 0, commonCounter: 0 },
-  }
-
-  await t.rejects(
-    license(state),
-    { message: /Failed to parse :license selector/ },
-    'should throw error for parsing failures other than missing query node',
-  )
-})

package/test/pseudo/link.ts

@@ -1,94 +0,0 @@
-import t from 'tap'
-import postcssSelectorParser from 'postcss-selector-parser'
-import type { ParserState } from '../../src/types.ts'
-import { link } from '../../src/pseudo/link.ts'
-import { getSimpleGraph, getLinkedGraph } from '../fixtures/graph.ts'
-
-t.test('selects file links and tar.gz packages', 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 that are file links in simple graph',
-    async t => {
-      // Based on the getSimpleGraph fixture, only '@x/y' is a file link
-      const res = await link(getState(':link'))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['@x/y'].sort(),
-        'should select only file link packages in simple graph',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test(
-    'selects nodes that are file links or tar.gz in linked graph',
-    async t => {
-      // In getLinkedGraph, 'a' is a file
-      const linkedGraph = getLinkedGraph()
-      const res = await link(getState(':link', linkedGraph))
-      t.strictSame(
-        [...res.partial.nodes].map(n => n.name).sort(),
-        ['a'].sort(),
-        'should select file links packages',
-      )
-      t.strictSame(
-        [...res.partial.edges].map(e => e.name).sort(),
-        ['a', 'd'].sort(),
-        'should select file links edges including to missing packages',
-      )
-      t.matchSnapshot({
-        nodes: [...res.partial.nodes].map(n => n.name).sort(),
-        edges: [...res.partial.edges].map(e => e.name).sort(),
-      })
-    },
-  )
-
-  await t.test('handles an empty partial state', async t => {
-    // Create a state with empty partial nodes
-    const state = getState(':link')
-    state.partial.nodes.clear()
-    state.partial.edges.clear()
-
-    const res = await link(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),
-    })
-  })
-})