treeresolver

TreeResolver

TreeResolver is dependency resolution library, made to resolve dependencies optimally whilst detecting unresolvable or circular dependencies.

TreeResolver itself provides single-parent dependency resolution, whilst DepResolver provides multi-parent dependency resolution.

Written in TypeScript.

license

MIT license; see ./LICENSE

documentation

Automatically generated documentation is available in /docs/.

TreeResolver - Single-parent dependency resolution

Usage is fairly simple. Create a new TreeResolver instance, add new instances by declaring their names, dependencies, and optional dependencies, and then build the relationship tree. The result should be a well-structured dependency tree free of unresolvable and circular dependencies.

import { TreeResolver } from 'TreeResolver'
const tree = new TreeResolver()

(async () => {
  tree.addInstance('node 1')
  tree.addInstance('node 2', 'node 1')
  tree.addInstance('node 3', 'node 4') // node 4 does not exist...
  tree.addInstance('node 5', 'node 2')

  const res = await tree.build()
  console.dir(res)
})()
/*
> { nodes:
   { 'node 1':
      { name: 'node 1',
        parent: undefined,
        parentNode: null,
        rootNode: null,
        children: [Object],
        allDescendants: [Object],
        allAncestors: {} } },
  nodeList:
   { 'node 1':
      { name: 'node 1',
        parent: undefined,
        parentNode: null,
        rootNode: null,
        children: [Object],
        allDescendants: [Object],
        allAncestors: {} },
     'node 2':
      { name: 'node 2',
        parent: 'node 1',
        parentNode: [Object],
        rootNode: [Object],
        children: [Object],
        allDescendants: [Object],
        allAncestors: [Object] },
     'node 3':
      { name: 'node 3',
        parent: 'node 4',
        parentNode: null,
        rootNode: null,
        children: {},
        allDescendants: {},
        allAncestors: {} },
     'node 5':
      { name: 'node 5',
        parent: 'node 2',
        parentNode: [Object],
        rootNode: [Object],
        children: {},
        allDescendants: {},
        allAncestors: [Object] } },
  unlinkedNodes:
   [ { name: 'node 3',
       parent: 'node 4',
       parentNode: null,
       rootNode: null,
       children: {},
       allDescendants: {},
       allAncestors: {} } ] }
 */

// nodes will contain a hierarchial tree map, keyed by name of the node
// nodeList will contain ALL nodes that were able to be mapped, keyed by the name of the node
// unlinkedNodes will contain an array of all nodes which could not be mapped, such as if
//   they had unresolvable dependencies or a circular dependency.

DepResolver - Multi-parent dependency resolution

Usage is fairly simple. Create a new DepResolver instance, add new instances by declaring their names, dependencies, and optional dependencies, and then build the relationship tree. The result should be a well-structured dependency tree free of unresolvable and circular dependencies.

import { DepResolver } from 'DepResolver'
const tree = new DepResolver()

(async () => {
  tree.addInstance('node 1')
  tree.addInstance('node 2', [], ['node 4']) // has an optional dependency on "node 4", which will not exist
  tree.addInstance('node 3', ['node 2'])
  tree.addInstance('node 5', ['node 1', 'node 2', 'node 3'])

  const res = await tree.build()
  console.dir(res)
})()

/*
> { nodes:
   { 'node 1':
      { name: 'node 1',
        parents: {},
        children: [Object],
        allDescendants: [Object],
        allAncestors: {},
        _parentNames: [],
        _optParentNames: [] },
     'node 2':
      { name: 'node 2',
        parents: {},
        children: [Object],
        allDescendants: [Object],
        allAncestors: {},
        _parentNames: [],
        _optParentNames: [Array] } },
  nodeList:
   { 'node 1':
      { name: 'node 1',
        parents: {},
        children: [Object],
        allDescendants: [Object],
        allAncestors: {},
        _parentNames: [],
        _optParentNames: [] },
     'node 2':
      { name: 'node 2',
        parents: {},
        children: [Object],
        allDescendants: [Object],
        allAncestors: {},
        _parentNames: [],
        _optParentNames: [Array] },
     'node 3':
      { name: 'node 3',
        parents: [Object],
        children: [Object],
        allDescendants: [Object],
        allAncestors: [Object],
        _parentNames: [Array],
        _optParentNames: [] },
     'node 5':
      { name: 'node 5',
        parents: [Object],
        children: {},
        allDescendants: {},
        allAncestors: [Object],
        _parentNames: [Array],
        _optParentNames: [] } },
  unlinkedNodes: [] }
 */

// upon closer inspection of the tree, you'll notice that the node
//   for 'node 2' contains its appropriate descendants in correct lineage, along with others.
//
// nodes will contain a hierarchial tree map, keyed by name of the node
// nodeList will contain ALL nodes that were able to be mapped, keyed by the name of the node
// unlinkedNodes will contain an array of all nodes which could not be mapped, such as if
//   they had unresolvable dependencies or a circular dependency.

tests

use yarn test to run unit tests