@vltpkg/query 1.0.0-rc.8 → 1.0.1

package/test/pseudo/hostname.ts

@@ -0,0 +1,314 @@
+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

@@ -0,0 +1,265 @@
+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

@@ -0,0 +1,94 @@
+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),
+    })
+  })
+})