node-dep-resolver 1.0.0

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

@@ -0,0 +1,10 @@
+export default function getFirstConflict() {
+  for (const packageName of this.conflicts) {
+    return {
+      packageName,
+      constraints: this.constraints.get(packageName)
+    };
+  }
+
+  return null;
+}

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

@@ -0,0 +1,9 @@
+import semver from "semver";
+
+export default async function getValidVersions(name, range) {
+  const versions = await this.registry.getVersions(name);
+
+  return versions
+    .filter(version => semver.satisfies(version, range))
+    .sort(semver.rcompare);
+}

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

@@ -0,0 +1,13 @@
+export default async function resolve() {
+  console.log("\nStarting resolution...\n");
+
+  await this.buildInitialState();
+
+  const result = await this.search();
+
+  if (!result) {
+    throw new Error("Could not find a valid dependency tree.");
+  }
+
+  return result;
+}

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

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

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

@@ -0,0 +1,39 @@
+export default async function search() {
+  const conflict = this.getFirstConflict();
+
+  if (!conflict) {
+    console.log("\n[SUCCESS] Valid dependency tree found.");
+    return new Map(this.selected);
+  }
+
+  console.log(`\n[CONFLICT] ${conflict.packageName}`);
+
+  const candidates = await this.candidates.generateCandidates(conflict);
+
+  for (const candidate of candidates) {
+    console.log(`Trying ${candidate.packageName}@${candidate.newVersion}`);
+
+    const snapshot = this.createSnapshot();
+
+    try {
+      await this.selectPackage(
+        candidate.packageName,
+        candidate.newVersion,
+        "RESOLUTION"
+      );
+
+      const result = await this.search();
+
+      if (result) {
+        return result;
+      }
+    } catch (error) {
+      console.log(error.message);
+    }
+
+    this.restoreSnapshot(snapshot);
+    console.log("[BACKTRACKING] Backtracking...");
+  }
+
+  return null;
+}

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

@@ -0,0 +1,19 @@
+export default async function selectPackage(name, version, requestedBy) {
+  this.selected.set(name, {
+    name,
+    version,
+    requestedBy
+  });
+
+  const packageData = await this.registry.getPackageVersion(name, version);
+
+  const dependencies = packageData.dependencies || {};
+
+  for (const [dependencyName, dependencyRange] of Object.entries(dependencies)) {
+    this.addConstraint(
+      dependencyName,
+      dependencyRange,
+      `${name}@${version}`
+    );
+  }
+}

package/src/index.js

@@ -0,0 +1,19 @@
+import Resolver from "./base/resolver/ResolverClass.js";
+import Registry from "./base/registry/RegistryClass.js";
+import Graph from "./base/graph/GraphClass.js";
+import Constraint from "./base/constraints/ConstraintClass.js";
+import Candidates from "./base/candidate/CandidateClass.js";
+import Dependency from "./base/dependencies/DependencyClass.js";
+import Conflict from "./base/conflicts/ConflictClass.js";
+
+export {
+  Resolver,
+  Registry,
+  Graph,
+  Constraint,
+  Candidates,
+  Dependency,
+  Conflict
+};
+
+export default Resolver;

package/src/rudimentary/candidates.js

@@ -0,0 +1,121 @@
+import semver from "semver";
+import {
+  getVersions,
+  getPackageVersion
+} from "./registry.js";
+
+export async function generateCandidates(
+  conflict
+) {
+  const candidates = [];
+
+  const packageName =
+    conflict.packageName;
+
+  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 getVersions(requesterName);
+
+    for (const version of versions) {
+
+      // Don't try the version we're already using
+      if (version === currentVersion) {
+        continue;
+      }
+
+      // Get this candidate's metadata
+      const packageData =
+        await getPackageVersion(
+          requesterName,
+          version
+        );
+
+      const dependencies =
+        packageData.dependencies || {};
+
+      // Does this version still depend on
+      // the conflicting package?
+      if (!dependencies[packageName]) {
+        candidates.push({
+          packageName: requesterName,
+          oldVersion: currentVersion,
+          newVersion: version,
+          reason: `No longer depends on ${packageName}`
+        });
+
+        continue;
+      }
+
+      const newRange =
+        dependencies[packageName];
+
+      // Does this new dependency range
+      // overlap with the other constraints?
+      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}`
+        });
+      }
+    }
+  }
+
+  // Prefer smaller version changes for now
+  candidates.sort((a, b) => {
+
+    return semver.compare(
+      a.newVersion,
+      a.oldVersion
+    );
+  });
+
+  return candidates;
+}

package/src/rudimentary/canditate.js

@@ -0,0 +1,121 @@
+import semver from "semver";
+import {
+    getVersions,
+    getPackageVersion
+} from "./registry.js";
+
+export async function generateCandidates(
+    conflict
+) {
+    const candidates = [];
+
+    const packageName =
+        conflict.packageName;
+
+    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 getVersions(requesterName);
+
+        for (const version of versions) {
+
+            // Don't try the version we're already using
+            if (version === currentVersion) {
+                continue;
+            }
+
+            // Get this candidate's metadata
+            const packageData =
+                await getPackageVersion(
+                    requesterName,
+                    version
+                );
+
+            const dependencies =
+                packageData.dependencies || {};
+
+            // Does this version still depend on
+            // the conflicting package?
+            if (!dependencies[packageName]) {
+                candidates.push({
+                    packageName: requesterName,
+                    oldVersion: currentVersion,
+                    newVersion: version,
+                    reason: `No longer depends on ${packageName}`
+                });
+
+                continue;
+            }
+
+            const newRange =
+                dependencies[packageName];
+
+            // Does this new dependency range
+            // overlap with the other constraints?
+            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}`
+                });
+            }
+        }
+    }
+
+    // Prefer smaller version changes for now
+    candidates.sort((a, b) => {
+
+        return semver.compare(
+            a.newVersion,
+            a.oldVersion
+        );
+    });
+
+    return candidates;
+}

package/src/rudimentary/constraint.js

@@ -0,0 +1,73 @@
+import semver from "semver";
+
+const constraints = new Map();
+
+const conflicts = new Set();
+
+export function addConstraint(
+  dependencyName,
+  dependencyRange,
+  requestedBy
+) {
+
+  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
+  });
+}
+
+export function getConstraints() {
+  return constraints;
+}
+
+export function getConflicts() {
+  return conflicts;
+}

package/src/rudimentary/graph.js

@@ -0,0 +1,124 @@
+import {
+    resolveVersion,
+    getPackageVersion
+} from "./registry.js";
+
+import {
+    addConstraint,
+    getConstraints,
+    getConflicts
+} from "./constraint.js";
+
+export const buildGraph = async (rootDependencies) => {
+
+    const graph = new Map();
+
+    async function visit(
+        name,
+        range,
+        requestedBy
+    ) {
+
+        console.log(
+            `Resolving ${name} ${range}...`
+        );
+
+        // Record constraint immediately
+        addConstraint(
+            name,
+            range,
+            requestedBy
+        );
+
+        const version =
+            await resolveVersion(
+                name,
+                range
+            );
+
+        const key = `${name}@${version}`;
+
+        // Already processed?
+        if (graph.has(key)) {
+            return;
+        }
+
+        const packageData =
+            await getPackageVersion(
+                name,
+                version
+            );
+
+        const node = {
+            name,
+            version,
+            dependencies:
+                packageData.dependencies || {}
+        };
+
+        graph.set(key, node);
+
+        // Visit dependencies
+        for (
+            const [
+                dependencyName,
+                dependencyRange
+            ]
+            of Object.entries(node.dependencies)
+        ) {
+
+            await visit(
+                dependencyName,
+                dependencyRange,
+                `${name}@${version}`
+            );
+        }
+    }
+
+    // Root dependencies
+    for (
+        const [
+            name,
+            range
+        ]
+        of Object.entries(rootDependencies)
+    ) {
+
+        await visit(
+            name,
+            range,
+            "ROOT"
+        );
+    }
+
+    return graph;
+}
+
+export const 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/rudimentary/registry.js

@@ -0,0 +1,70 @@
+import axios from "axios";
+import semver from "semver";
+//done
+const REGISTRY_URL = "https://registry.npmjs.org";
+//done
+const metadataCache = new Map();
+
+export async function getPackageMetadata(name) {
+  if (metadataCache.has(name)) {
+    return metadataCache.get(name);
+  }
+
+  const url =
+    `${REGISTRY_URL}/${encodeURIComponent(name)}`;
+
+  const response = await axios.get(url);
+
+  metadataCache.set(name, response.data);
+
+  return response.data;
+}
+
+export async function resolveVersion(name, range) {
+  const metadata =
+    await 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];
+}
+
+export async function getPackageVersion(
+  name,
+  version
+) {
+  const metadata =
+    await getPackageMetadata(name);
+
+  const packageData =
+    metadata.versions[version];
+
+  if (!packageData) {
+    throw new Error(
+      `${name}@${version} does not exist`
+    );
+  }
+
+  return packageData;
+}
+
+export async function getVersions(name) {
+  const metadata =
+    await getPackageMetadata(name);
+
+  return Object.keys(metadata.versions);
+}