node-dep-resolver 1.0.0

package/bin/cli.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import Graph from "../src/base/graph/GraphClass.js";
+import Resolver from "../src/base/resolver/ResolverClass.js";
+
+async function runCli() {
+  const targetPath = process.argv[2] || "./package.json";
+  const absolutePath = path.resolve(process.cwd(), targetPath);
+
+  if (!fs.existsSync(absolutePath)) {
+    console.error(`[ERROR] File not found at '${absolutePath}'`);
+    process.exit(1);
+  }
+
+  console.log(`\n[INFO] Analyzing dependencies from '${targetPath}'...\n`);
+
+  let packageJson;
+  try {
+    packageJson = JSON.parse(fs.readFileSync(absolutePath, "utf-8"));
+  } catch (err) {
+    console.error(`[ERROR] Failed to parse JSON in '${targetPath}'`);
+    process.exit(1);
+  }
+
+  const dependencies = {
+    ...(packageJson.dependencies || {})
+  };
+
+  if (Object.keys(dependencies).length === 0) {
+    console.log("[INFO] No dependencies found in package.json.");
+    process.exit(0);
+  }
+
+  console.log("--- Building Dependency Graph ---");
+  const graphObj = new Graph();
+  const graph = await graphObj.buildGraph(dependencies);
+  graphObj.printGraph(graph);
+
+  console.log("\n--- Resolving Conflicts ---");
+  const resolver = new Resolver(dependencies);
+  const solution = await resolver.resolve();
+
+  console.log("\n========== RESOLVED DEPENDENCY SOLUTION ==========\n");
+  for (const [name, packageData] of solution) {
+    console.log(`  [OK] ${name}@${packageData.version}`);
+  }
+  console.log();
+}
+
+runCli().catch((err) => {
+  console.error("[ERROR] Fatal Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "node-dep-resolver",
+  "version": "1.0.0",
+  "description": "A lightweight CLI tool & library to build dependency graphs and resolve semver conflicts.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "dep-resolver": "bin/cli.js"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "scripts": {
+    "test": "node --test test/*.js",
+    "start": "node bin/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unknownsideofme/dependency-resolver.git"
+  },
+  "keywords": [
+    "cli",
+    "dependency-resolver",
+    "semver",
+    "dependency-graph",
+    "conflict-resolution",
+    "backtracking"
+  ],
+  "author": "debanjan",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.7.0",
+    "semver": "^7.6.0"
+  }
+}

package/src/base/candidate/CandidateClass.js

@@ -0,0 +1,20 @@
+import Conflict from "../conflicts/ConflictClass.js"; 
+import Registry from "../registry/RegistryClass.js";
+import Dependency from "../dependencies/DependencyClass.js";
+import generateCandidates from "./methods/generateCandidate.js";
+
+export default class Candidates {
+    constructor(registry) {
+        this.conflicts = new Conflict(); 
+        this.registry = registry || new Registry(new Dependency());
+    }
+
+    getConflicts() {
+        if (this.conflicts === null) {
+            throw new Error("Conflict not initialized");
+        }
+        return this.conflicts;
+    }
+}
+
+Candidates.prototype.generateCandidates = generateCandidates;

package/src/base/candidate/methods/generateCandidate.js

@@ -0,0 +1,73 @@
+import semver from "semver";
+
+export default async function generateCandidates(conflict) {
+  const candidates = [];
+  const packageName = conflict.packageName;
+  const registry = this.registry;
+
+  for (const requirement of conflict.constraints) {
+    const requester = requirement.requester;
+    const requesterParts = requester.split("@");
+    const requesterName = requesterParts[0];
+    const currentVersion = requesterParts.slice(1).join("@");
+
+    console.log(`\nLooking for alternatives for ${requester}`);
+
+    const versions = await registry.getVersions(requesterName);
+
+    for (const version of versions) {
+      if (version === currentVersion) {
+        continue;
+      }
+
+      const packageData = await registry.getPackageVersion(
+        requesterName,
+        version
+      );
+
+      const dependencies = packageData.dependencies || {};
+
+      if (!dependencies[packageName]) {
+        candidates.push({
+          packageName: requesterName,
+          oldVersion: currentVersion,
+          newVersion: version,
+          reason: `No longer depends on ${packageName}`
+        });
+
+        continue;
+      }
+
+      const newRange = dependencies[packageName];
+      let compatible = true;
+
+      for (const other of conflict.constraints) {
+        if (other.requester === requester) {
+          continue;
+        }
+
+        if (!semver.intersects(newRange, other.range)) {
+          compatible = false;
+          break;
+        }
+      }
+
+      if (compatible) {
+        candidates.push({
+          packageName: requesterName,
+          oldVersion: currentVersion,
+          newVersion: version,
+          reason:
+            `${requesterName}@${version} requires ` +
+            `${packageName} ${newRange}`
+        });
+      }
+    }
+  }
+
+  candidates.sort((a, b) => {
+    return semver.compare(a.newVersion, a.oldVersion);
+  });
+
+  return candidates;
+}

package/src/base/conflicts/ConflictClass.js

@@ -0,0 +1,12 @@
+export default class Conflict {
+    static conflicts = null;
+
+    constructor() {
+        if (Conflict.conflicts === null) {
+            Conflict.conflicts = new Set();
+        }
+        return Conflict.conflicts;
+    }
+
+    
+}

package/src/base/constraints/ConstraintClass.js

@@ -0,0 +1,27 @@
+import Conflict from "../conflicts/ConflictClass.js";
+import { addConstraint } from "./methods/addConstraint.js";
+export default class Constraint {
+    static #constraints = null;
+    static #conflicts = null ; 
+
+    constructor() {
+       this.constraints = new Map() ; 
+       this.conflicts =  new Conflict() ; 
+
+    }
+    getConstraints(){
+        if( this.constraints === null){
+            throw new Error( "Conflicts not initialized") ; 
+        }
+        return this.constraints ;
+    }
+
+    getConflicts(){
+        if(this.conflicts === null ){
+            throw new Error( "Conflicts not initialized") ;
+        }
+        return this.conflicts ;
+    }
+   
+}
+Constraint.prototype.addConstraint = addConstraint ;

package/src/base/constraints/methods/addConstraint.js

@@ -0,0 +1,69 @@
+import semver from "semver";
+
+export function addConstraint(
+  dependencyName,
+  dependencyRange,
+  requestedBy
+) {
+  if(dependencyName === null || dependencyName == ""){
+    throw new Error("Dependency name cannot be null or empty");
+  }
+  if( dependencyRange === null || dependencyRange == ""){
+    throw new Error("Dependency range cannot be null or empty");
+  }
+  if( requestedBy === null || requestedBy == ""){
+    throw new Error("Requested by cannot be null or empty");
+  }
+  let constraints = this.getConstraints() ; 
+  let conflicts = this.getConflicts() ;
+  if (!constraints.has(dependencyName)) {
+
+    constraints.set(
+      dependencyName,
+      {
+        constraints: [],
+        conflict: false
+      }
+    );
+  }
+
+  const state = constraints.get(dependencyName);
+
+  // Avoid duplicate constraints
+  const alreadyExists = state.constraints.some(
+      item =>
+        item.requester === requestedBy &&
+        item.range === dependencyRange
+    );
+
+  if (alreadyExists) {
+    return;
+  }
+
+  // Check against existing constraints
+  for (
+    const existing
+    of state.constraints
+  ) {
+
+    const compatible =
+      semver.intersects(
+        existing.range,
+        dependencyRange
+      );
+
+    if (!compatible) {
+
+      state.conflict = true;
+
+      conflicts.add(
+        dependencyName
+      );
+    }
+  }
+
+  state.constraints.push({
+    requester: requestedBy,
+    range: dependencyRange
+  });
+}

package/src/base/dependencies/DependencyClass.js

@@ -0,0 +1,10 @@
+export default class Dependency {
+    //singleton Dependency Cache
+    static metadataCache = null;
+    constructor() {
+        if (Dependency.metadataCache === null) {
+            Dependency.metadataCache = new Map();
+        }
+        return Dependency.metadataCache;
+    }
+}

package/src/base/graph/GraphClass.js

@@ -0,0 +1,20 @@
+import buildGraph from "./method/buildGraph.js";
+import printGraph from "./method/printGraph.js";
+
+export default class Graph {
+    static graphMap = null;
+
+    constructor() {
+        if (Graph.graphMap === null) {
+            Graph.graphMap = new Map();
+        }
+        this.graphMap = Graph.graphMap;
+    }
+
+    getGraphMap() {
+        return this.graphMap;
+    }
+}
+
+Graph.prototype.buildGraph = buildGraph;
+Graph.prototype.printGraph = printGraph;

package/src/base/graph/method/buildGraph.js

@@ -0,0 +1,80 @@
+import {
+  resolveVersion,
+  getPackageVersion
+} from "../../../rudimentary/registry.js";
+
+import {
+  addConstraint
+} from "../../../rudimentary/constraint.js";
+
+export default async function buildGraph(rootDependencies) {
+  const graph = new Map();
+
+  async function visit(
+    name,
+    range,
+    requestedBy
+  ) {
+    console.log(`Resolving ${name} ${range}...`);
+
+    addConstraint(
+      name,
+      range,
+      requestedBy
+    );
+
+    const version = await resolveVersion(
+      name,
+      range
+    );
+
+    const key = `${name}@${version}`;
+
+    if (graph.has(key)) {
+      return;
+    }
+
+    const packageData = await getPackageVersion(
+      name,
+      version
+    );
+
+    const node = {
+      name,
+      version,
+      dependencies: packageData.dependencies || {}
+    };
+
+    graph.set(key, node);
+
+    for (
+      const [
+        dependencyName,
+        dependencyRange
+      ]
+      of Object.entries(node.dependencies)
+    ) {
+      await visit(
+        dependencyName,
+        dependencyRange,
+        `${name}@${version}`
+      );
+    }
+  }
+
+  for (
+    const [
+      name,
+      range
+    ]
+    of Object.entries(rootDependencies)
+  ) {
+    await visit(
+      name,
+      range,
+      "ROOT"
+    );
+  }
+
+  return graph;
+}

package/src/base/graph/method/printGraph.js

@@ -0,0 +1,33 @@
+import {
+  getConstraints,
+  getConflicts
+} from "../../../rudimentary/constraint.js";
+
+export default function printGraph(graph) {
+  for (const [key, node] of graph) {
+    console.log(key);
+    for (const [name, range] of Object.entries(node.dependencies)) {
+      console.log(`  └── ${name} ${range}`);
+    }
+    console.log();
+  }
+
+  const constraints = getConstraints();
+  const conflicts = getConflicts();
+
+  if (constraints.size > 0) {
+    console.log("========== CONSTRAINTS & CONFLICTS ==========\n");
+    for (const [depName, state] of constraints) {
+      const status = state.conflict ? "CONFLICT" : "OK";
+      console.log(`${depName} [${status}]`);
+      for (const r of state.constraints) {
+        console.log(`  └── requested ${r.range} by ${r.requester}`);
+      }
+      console.log();
+    }
+
+    if (conflicts.size > 0) {
+      console.log(`[WARNING] Conflicts detected in ${conflicts.size} package(s): ${Array.from(conflicts).join(", ")}\n`);
+    }
+  }
+}

package/src/base/registry/RegistryClass.js

@@ -0,0 +1,33 @@
+import getPackageMetadata from "./methods/getPackageMetadata.js";
+import resolveVersion from "./methods/resolveVersion.js";
+import getPackageVersion from "./methods/getPackageVersion.js";
+import getVersions from "./methods/getVersions.js";
+import Dependency from "../dependencies/DependencyClass.js";
+
+export default class Registry {
+    static #REGISTRY_URL = "https://registry.npmjs.org";
+    static #metadataCache = null;
+
+    constructor() {
+        if (Registry.#metadataCache === null) {
+            Registry.#metadataCache = new Dependency();
+        }
+    }
+
+    getMetadataCache() {
+        return Registry.#metadataCache;
+    }
+
+    setMetadataCache(metadataCache) {
+        Registry.#metadataCache = metadataCache;
+    }
+
+    getREGISTRY_URL() {
+        return Registry.#REGISTRY_URL;
+    }
+}
+
+Registry.prototype.getPackageMetadata = getPackageMetadata;
+Registry.prototype.resolveVersion = resolveVersion;
+Registry.prototype.getPackageVersion = getPackageVersion;
+Registry.prototype.getVersions = getVersions;

package/src/base/registry/methods/getPackageMetadata.js

@@ -0,0 +1,18 @@
+import axios from "axios";
+
+export default async function getPackageMetadata(name) {
+  const metadataCache = this.getMetadataCache();
+  if (metadataCache && metadataCache.has(name)) {
+    return metadataCache.get(name);
+  }
+  const registryUrl = this.getREGISTRY_URL();
+  const url = `${registryUrl}/${encodeURIComponent(name)}`;
+
+  const response = await axios.get(url);
+
+  if (metadataCache) {
+    metadataCache.set(name, response.data);
+  }
+
+  return response.data;
+}

package/src/base/registry/methods/getPackageVersion.js

@@ -0,0 +1,13 @@
+export default async function getPackageVersion(name, version) {
+  const metadata = await this.getPackageMetadata(name);
+
+  const packageData = metadata.versions[version];
+
+  if (!packageData) {
+    throw new Error(
+      `${name}@${version} does not exist`
+    );
+  }
+
+  return packageData;
+}

package/src/base/registry/methods/getVersions.js

@@ -0,0 +1,5 @@
+export default async function getVersions(name) {
+  const metadata = await this.getPackageMetadata(name);
+
+  return Object.keys(metadata.versions);
+}

package/src/base/registry/methods/resolveVersion.js

@@ -0,0 +1,17 @@
+import semver from "semver";
+
+export default async function resolveVersion(name, range) {
+  const metadata = await this.getPackageMetadata(name);
+  const versions = Object.keys(metadata.versions);
+  const validVersions = versions.filter(version => semver.satisfies(version, range));
+
+  if (validVersions.length === 0) {
+    throw new Error(
+      `No version of ${name} satisfies ${range}`
+    );
+  }
+
+  validVersions.sort(semver.rcompare);
+
+  return validVersions[0];
+}

package/src/base/resolver/ResolverClass.js

@@ -0,0 +1,87 @@
+import Registry from "../registry/RegistryClass.js";
+import Candidates from "../candidate/CandidateClass.js";
+import Constraint from "../constraints/ConstraintClass.js";
+import Conflict from "../conflicts/ConflictClass.js";
+
+import resolve from "./methods/resolve.js";
+import buildInitialState from "./methods/buildInitialState.js";
+import getValidVersions from "./methods/getValidVersions.js";
+import selectPackage from "./methods/selectPackage.js";
+import addConstraint from "./methods/addConstraint.js";
+import checkConflict from "./methods/checkConflict.js";
+import getFirstConflict from "./methods/getFirstConflict.js";
+import search from "./methods/search.js";
+import createSnapshot from "./methods/createSnapshot.js";
+import restoreSnapshot from "./methods/restoreSnapshot.js";
+
+export default class Resolver {
+  static #rootDependencies = null;
+  static #selected = null;
+  static #constraints = null;
+  static #conflicts = null;
+  static #registry = null;
+  static #candidates = null;
+
+  constructor(rootDependencies, registry, candidates, constraint) {
+    this.rootDependencies = { ...rootDependencies };
+    this.selected = new Map();
+    this.constraintObj = constraint || new Constraint();
+    this.constraints = this.constraintObj.getConstraints();
+    this.conflicts = new Conflict();
+    this.registry = registry || new Registry();
+    this.candidates = candidates || new Candidates(this.registry);
+  }
+
+  getRootDependencies() {
+    if (this.rootDependencies === null) {
+      throw new Error("RootDependencies not initialized");
+    }
+    return this.rootDependencies;
+  }
+
+  getSelected() {
+    if (this.selected === null) {
+      throw new Error("Selected not initialized");
+    }
+    return this.selected;
+  }
+
+  getConstraints() {
+    if (this.constraints === null) {
+      throw new Error("Constraints not initialized");
+    }
+    return this.constraints;
+  }
+
+  getConflicts() {
+    if (this.conflicts === null) {
+      throw new Error("Conflicts not initialized");
+    }
+    return this.conflicts;
+  }
+
+  getRegistry() {
+    if (this.registry === null) {
+      throw new Error("Registry not initialized");
+    }
+    return this.registry;
+  }
+
+  getCandidates() {
+    if (this.candidates === null) {
+      throw new Error("Candidates not initialized");
+    }
+    return this.candidates;
+  }
+}
+
+Resolver.prototype.resolve = resolve;
+Resolver.prototype.buildInitialState = buildInitialState;
+Resolver.prototype.getValidVersions = getValidVersions;
+Resolver.prototype.selectPackage = selectPackage;
+Resolver.prototype.addConstraint = addConstraint;
+Resolver.prototype.checkConflict = checkConflict;
+Resolver.prototype.getFirstConflict = getFirstConflict;
+Resolver.prototype.search = search;
+Resolver.prototype.createSnapshot = createSnapshot;
+Resolver.prototype.restoreSnapshot = restoreSnapshot;

package/src/base/resolver/methods/addConstraint.js

@@ -0,0 +1,12 @@
+export default function addConstraint(name, range, requester) {
+  if (!this.constraints.has(name)) {
+    this.constraints.set(name, []);
+  }
+
+  this.constraints.get(name).push({
+    requester,
+    range
+  });
+
+  this.checkConflict(name);
+}

package/src/base/resolver/methods/buildInitialState.js

@@ -0,0 +1,11 @@
+export default async function buildInitialState() {
+  for (const [name, range] of Object.entries(this.rootDependencies)) {
+    const versions = await this.getValidVersions(name, range);
+
+    if (versions.length === 0) {
+      throw new Error(`No version of ${name} satisfies ${range}`);
+    }
+
+    await this.selectPackage(name, versions[0], "ROOT");
+  }
+}

package/src/base/resolver/methods/checkConflict.js

@@ -0,0 +1,20 @@
+import semver from "semver";
+
+export default function checkConflict(name) {
+  const requirements = this.constraints.get(name);
+
+  if (!requirements) {
+    return;
+  }
+
+  for (let i = 0; i < requirements.length; i++) {
+    for (let j = i + 1; j < requirements.length; j++) {
+      if (!semver.intersects(requirements[i].range, requirements[j].range)) {
+        this.conflicts.add(name);
+        return;
+      }
+    }
+  }
+
+  this.conflicts.delete(name);
+}

package/src/base/resolver/methods/createSnapshot.js

@@ -0,0 +1,12 @@
+export default function createSnapshot() {
+  return {
+    selected: new Map(this.selected),
+    constraints: new Map(
+      [...this.constraints].map(([name, values]) => [
+        name,
+        values.map(value => ({ ...value }))
+      ])
+    ),
+    conflicts: new Set(this.conflicts)
+  };
+}