@vltpkg/graph 1.0.0-rc.23 → 1.0.0-rc.24

package/dist/stringify-node.js

@@ -0,0 +1,32 @@
+import { splitDepID } from '@vltpkg/dep-id/browser';
+import { defaultRegistryName } from '@vltpkg/spec/browser';
+export const stringifyNode = (node) => {
+    if (!node)
+        return '';
+    const version = node.version ? `@${node.version}` : '';
+    const [type, ref, nameVersion] = splitDepID(node.id);
+    if (type === 'registry') {
+        let prefix = `${defaultRegistryName}:`;
+        if (ref) {
+            if (/^https?:\/\//.test(ref)) {
+                prefix = `registry:${ref}#`;
+            }
+            else {
+                prefix = `${ref}:`;
+            }
+        }
+        return `${prefix}${nameVersion}`;
+    }
+    else if (type === 'workspace') {
+        return `workspace:${node.name}`;
+    }
+    else if (type === 'file' && node.mainImporter) {
+        return `root:${node.name}`;
+    }
+    else {
+        // node.name getter will return the id if the package has no name
+        // property so here we check for that in order to return `type(ref)` only
+        const nameVersion = node.name !== node.id ? `:${node.name}${version}` : '';
+        return `${type}(${ref})${nameVersion}`;
+    }
+};

package/dist/transfer-data/load.d.ts

@@ -0,0 +1,43 @@
+import { SecurityArchive } from '@vltpkg/security-archive/browser';
+import type { GraphLike, NormalizedManifest } from '@vltpkg/types';
+import type { LockfileData } from '../lockfile/types.ts';
+import type { SpecOptionsFilled } from '@vltpkg/spec/browser';
+/**
+ * The returned object when loading a graph from a transfer data structure,
+ * including the graph itself, the spec options used to create it, and
+ * the security archive (if any).
+ */
+export type LoadResult = {
+    graph: GraphLike;
+    specOptions: SpecOptionsFilled;
+    securityArchive: SecurityArchive | undefined;
+};
+/**
+ * A data structure defining a complete graph to be transfered, including
+ * extra information to the lockfile such as project info and importers.
+ */
+export type TransferData = {
+    importers: {
+        importer: boolean;
+        mainImporter: boolean;
+        id: string;
+        name: string;
+        version: string;
+        location: string;
+        manifest: NormalizedManifest;
+        projectRoot?: string;
+        integrity?: string;
+        resolved?: string;
+        dev?: boolean;
+        optional?: boolean;
+    }[];
+    lockfile: LockfileData;
+    projectInfo: {
+        root: string;
+        homedirRelativeRoot: string;
+        tools?: string[];
+        vltInstalled?: boolean;
+    };
+    securityArchive?: any;
+};
+export declare const load: (transfered: TransferData) => LoadResult;

package/dist/transfer-data/load.js

@@ -0,0 +1,175 @@
+import { error } from '@vltpkg/error-cause';
+import { SecurityArchive } from '@vltpkg/security-archive/browser';
+import { defaultGitHostArchives, defaultGitHosts, defaultRegistries, defaultRegistry, defaultScopeRegistries, } from '@vltpkg/spec/browser';
+import { stringifyNode } from "../stringify-node.js";
+import { loadEdges } from "../lockfile/load-edges.js";
+import { loadNodes } from "../lockfile/load-nodes.js";
+const loadSpecOptions = (lockfile) => {
+    const { catalog = {}, catalogs = {}, registries, registry, 'git-hosts': gitHosts, 'git-host-archives': gitHostArchives, 'scope-registries': scopeRegistries, 'jsr-registries': jsrRegistries, } = lockfile.options;
+    return {
+        catalog,
+        catalogs,
+        registries: { ...defaultRegistries, ...registries },
+        registry: registry || defaultRegistry,
+        'jsr-registries': { ...jsrRegistries },
+        'git-hosts': { ...defaultGitHosts, ...gitHosts },
+        'git-host-archives': {
+            ...defaultGitHostArchives,
+            ...gitHostArchives,
+        },
+        'scope-registries': {
+            ...defaultScopeRegistries,
+            ...scopeRegistries,
+        },
+    };
+};
+export const load = (transfered) => {
+    const [mainImporter] = transfered.importers;
+    const maybeGraph = {
+        importers: new Set(),
+        edges: new Set(),
+        nodes: new Map(),
+        nodesByName: new Map(),
+        projectRoot: transfered.projectInfo.root,
+        addEdge(type, spec, from, to) {
+            const existing = from.edgesOut.get(spec.name);
+            if (existing) {
+                const edge = existing;
+                if (edge.type === type &&
+                    edge.spec.bareSpec === spec.bareSpec) {
+                    if (to && to !== edge.to) {
+                        edge.to = to;
+                        edge.to.edgesIn.add(edge);
+                    }
+                    return edge;
+                }
+                this.edges.delete(edge);
+            }
+            const edge = {
+                from,
+                name: spec.name,
+                spec,
+                to,
+                type,
+            };
+            from.edgesOut.set(spec.name, edge);
+            to?.edgesIn.add(edge);
+            this.edges.add(edge);
+            return edge;
+        },
+        addNode(id, manifest) {
+            const graph = this;
+            if (!id)
+                throw error('id is required', { manifest });
+            if (!manifest)
+                throw error('manifest is required');
+            const node = {
+                id,
+                name: manifest.name,
+                version: manifest.version,
+                manifest,
+                edgesIn: new Set(),
+                edgesOut: new Map(),
+                workspaces: undefined,
+                graph,
+                importer: false,
+                mainImporter: false,
+                projectRoot: graph.projectRoot,
+                dev: false,
+                optional: false,
+                options: transfered.lockfile.options,
+                confused: false,
+                setResolved() { },
+                setConfusedManifest(fixed, confused) {
+                    this.manifest = fixed;
+                    this.rawManifest = confused;
+                    this.confused = true;
+                },
+                maybeSetConfusedManifest() { },
+                toJSON() {
+                    return {
+                        id: this.id,
+                        name: this.name,
+                        version: this.version,
+                        location: this.location,
+                        importer: this.importer,
+                        manifest: this.manifest,
+                        projectRoot: this.projectRoot,
+                        integrity: this.integrity,
+                        resolved: this.resolved,
+                        dev: this.dev,
+                        optional: this.optional,
+                        confused: this.confused,
+                        ...(this.confused ?
+                            { rawManifest: this.rawManifest }
+                            : undefined),
+                    };
+                },
+                toString() {
+                    return stringifyNode(this);
+                },
+            };
+            this.nodes.set(node.id, node);
+            if (node.name) {
+                const allNodesWithThisName = this.nodesByName.get(node.name) ?? new Set();
+                allNodesWithThisName.add(node);
+                this.nodesByName.set(node.name, allNodesWithThisName);
+            }
+            return node;
+        },
+    };
+    // configure importer nodes
+    for (const importer of transfered.importers) {
+        const id = importer.id;
+        const graph = maybeGraph;
+        const node = graph.addNode(id, importer.manifest);
+        node.importer = true;
+        node.mainImporter = importer.id === mainImporter?.id;
+        node.location = importer.location;
+        node.integrity = importer.integrity;
+        node.resolved = importer.resolved;
+        /* c8 ignore next 2 */
+        node.dev = importer.dev ?? false;
+        node.optional = importer.optional ?? false;
+        node.confused = false;
+        node.toJSON = () => ({
+            id: node.id,
+            name: node.name,
+            version: node.version,
+            location: node.location,
+            importer: node.importer,
+            manifest: node.manifest,
+            projectRoot: node.projectRoot,
+            integrity: node.integrity,
+            resolved: node.resolved,
+            dev: node.dev,
+            optional: node.optional,
+            confused: node.confused,
+        });
+        node.toString = () => stringifyNode(node);
+        // should set the main importer in the first iteration
+        graph.mainImporter ??= node;
+        graph.importers.add(node);
+    }
+    // populate nodes and edges from loaded data
+    const graph = maybeGraph;
+    const specOptions = loadSpecOptions(transfered.lockfile);
+    loadNodes(graph, transfered.lockfile.nodes, specOptions, graph);
+    loadEdges(graph, transfered.lockfile.edges, specOptions);
+    const securityArchive = SecurityArchive.load(transfered.securityArchive);
+    // validates that all nodes have a security archive entry
+    if (securityArchive) {
+        securityArchive.ok = true;
+        for (const node of graph.nodes.values()) {
+            if (!securityArchive.has(node.id)) {
+                securityArchive.ok = false;
+                break;
+            }
+        }
+    }
+    return {
+        graph,
+        specOptions,
+        securityArchive,
+    };
+};

package/dist/uninstall.d.ts

@@ -0,0 +1,14 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { LoadOptions } from './actual/load.ts';
+import type { RemoveImportersDependenciesMap } from './dependencies.ts';
+export type UninstallOptions = LoadOptions & {
+    packageInfo: PackageInfoClient;
+    allowScripts: string;
+};
+export declare const uninstall: (options: UninstallOptions, remove?: RemoveImportersDependenciesMap) => Promise<{
+    graph: import("./graph.ts").Graph;
+    diff: undefined;
+} | {
+    graph: import("./graph.ts").Graph;
+    diff: import("./reify/index.ts").ReifyResult;
+}>;

package/dist/uninstall.js

@@ -0,0 +1,75 @@
+import { load as actualLoad } from "./actual/load.js";
+import { GraphModifier } from "./modifiers.js";
+import { build as idealBuild } from "./ideal/build.js";
+import { reify } from "./reify/index.js";
+import { lockfile } from "./index.js";
+import { updatePackageJson } from "./reify/update-importers-package-json.js";
+import { RollbackRemove } from '@vltpkg/rollback-remove';
+import { existsSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+export const uninstall = async (options, remove) => {
+    const mainManifest = options.packageJson.read(options.projectRoot);
+    const modifiers = GraphModifier.maybeLoad(options);
+    const remover = new RollbackRemove();
+    try {
+        // Load the actual graph before building the ideal graph so that
+        // manifest data from installed packages can be used to hydrate
+        // nodes loaded from the lockfile. Without this, nodes loaded from
+        // vlt-lock.json (which does not store manifests) will be missing
+        // manifest data, causing the hidden lockfile save to silently fail
+        // due to throwOnMissingManifest and leaving stale entries behind.
+        const act = actualLoad({
+            ...options,
+            modifiers: undefined,
+            mainManifest,
+            loadManifests: true,
+        });
+        const graph = await idealBuild({
+            ...options,
+            actual: act,
+            remove,
+            mainManifest,
+            loadManifests: true,
+            remover,
+        });
+        // If lockfileOnly is enabled, skip reify and only save the lockfile
+        if (options.lockfileOnly) {
+            // Save only the main lockfile, skip all filesystem operations
+            lockfile.save({ graph, modifiers });
+            const saveImportersPackageJson = 
+            /* c8 ignore next */
+            remove?.modifiedDependencies ?
+                updatePackageJson({
+                    ...options,
+                    remove,
+                    graph,
+                })
+                : undefined;
+            saveImportersPackageJson?.();
+            return { graph, diff: undefined };
+        }
+        const diff = await reify({
+            ...options,
+            remove,
+            actual: act,
+            graph,
+            loadManifests: true,
+            remover,
+        });
+        return { graph, diff };
+        /* c8 ignore start */
+    }
+    catch (err) {
+        await remover.rollback().catch(() => { });
+        // Remove hidden lockfile on failure
+        try {
+            const hiddenLockfile = resolve(options.projectRoot, 'node_modules/.vlt-lock.json');
+            if (existsSync(hiddenLockfile)) {
+                rmSync(hiddenLockfile, { force: true });
+            }
+        }
+        catch { }
+        throw err;
+    }
+    /* c8 ignore stop */
+};

package/dist/update.d.ts

@@ -0,0 +1,12 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { LoadOptions } from './actual/load.ts';
+import { Graph } from './graph.ts';
+export type UpdateOptions = LoadOptions & {
+    packageInfo: PackageInfoClient;
+    allowScripts: string;
+};
+export declare const update: (options: UpdateOptions) => Promise<{
+    buildQueue: import("@vltpkg/dep-id").DepID[] | undefined;
+    graph: Graph;
+    diff: import("./diff.ts").Diff;
+}>;

package/dist/update.js

@@ -0,0 +1,73 @@
+import { load as actualLoad } from "./actual/load.js";
+import { buildIdealFromStartingGraph } from "./ideal/build-ideal-from-starting-graph.js";
+import { reify } from "./reify/index.js";
+import { GraphModifier } from "./modifiers.js";
+import { init } from '@vltpkg/init';
+import { asError } from '@vltpkg/types';
+import { Graph } from "./graph.js";
+import { graphStep } from '@vltpkg/output';
+import { RollbackRemove } from '@vltpkg/rollback-remove';
+import { existsSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+export const update = async (options) => {
+    let mainManifest = undefined;
+    try {
+        mainManifest = options.packageJson.read(options.projectRoot);
+    }
+    catch (err) {
+        if (asError(err).message === 'Could not read package.json file') {
+            await init({ cwd: options.projectRoot });
+            mainManifest = options.packageJson.read(options.projectRoot, {
+                reload: true,
+            });
+        }
+        else {
+            throw err;
+        }
+    }
+    const modifiers = GraphModifier.maybeLoad(options);
+    const remover = new RollbackRemove();
+    try {
+        const done = graphStep('build');
+        const graph = await buildIdealFromStartingGraph({
+            ...options,
+            add: Object.assign(new Map(), { modifiedDependencies: false }),
+            remove: Object.assign(new Map(), {
+                modifiedDependencies: false,
+            }),
+            graph: new Graph({ ...options, mainManifest }),
+            modifiers,
+            remover,
+        });
+        done();
+        const act = actualLoad({
+            ...options,
+            mainManifest,
+            loadManifests: true,
+        });
+        const { buildQueue, diff } = await reify({
+            ...options,
+            actual: act,
+            graph,
+            loadManifests: true,
+            modifiers,
+            remover,
+            update: true,
+        });
+        return { buildQueue, graph, diff };
+        /* c8 ignore start */
+    }
+    catch (err) {
+        await remover.rollback().catch(() => { });
+        // Remove hidden lockfile on failure
+        try {
+            const hiddenLockfile = resolve(options.projectRoot, 'node_modules/.vlt-lock.json');
+            if (existsSync(hiddenLockfile)) {
+                rmSync(hiddenLockfile, { force: true });
+            }
+        }
+        catch { }
+        throw err;
+    }
+    /* c8 ignore stop */
+};

package/dist/virtual-root.d.ts

@@ -0,0 +1,15 @@
+import type { SpecOptions } from '@vltpkg/spec/browser';
+import type { NodeLike } from '@vltpkg/types';
+/**
+ * An unique DepID to identify the virtual root node.
+ */
+export declare const VIRTUAL_ROOT_ID: import("@vltpkg/dep-id/browser").DepID;
+/**
+ * A virtual root used to aggregate multiple importers into a single graph.
+ *
+ * This is meant to be used with visual tools that want a single root node
+ * starting point to represent the graph.
+ *
+ * Returns undefined if a virtual root is not needed.
+ */
+export declare const createVirtualRoot: (name: string | undefined, options: SpecOptions, mainImporters: NodeLike[]) => NodeLike | undefined;

package/dist/virtual-root.js

@@ -0,0 +1,78 @@
+import { Spec } from '@vltpkg/spec/browser';
+import { joinDepIDTuple } from '@vltpkg/dep-id/browser';
+/**
+ * An unique DepID to identify the virtual root node.
+ */
+export const VIRTUAL_ROOT_ID = joinDepIDTuple([
+    'file',
+    '__virtual%root__',
+]);
+/**
+ * A virtual root used to aggregate multiple importers into a single graph.
+ *
+ * This is meant to be used with visual tools that want a single root node
+ * starting point to represent the graph.
+ *
+ * Returns undefined if a virtual root is not needed.
+ */
+export const createVirtualRoot = (name = 'virtual-root', options, mainImporters) => {
+    const res = {
+        id: VIRTUAL_ROOT_ID,
+        name,
+        version: '1.0.0',
+        manifest: {
+            name,
+            version: '1.0.0',
+        },
+        edgesIn: new Set(),
+        edgesOut: new Map([]),
+        confused: false,
+        importer: true,
+        mainImporter: true,
+        location: '.',
+        graph: { importers: new Set() },
+        projectRoot: '',
+        dev: false,
+        optional: false,
+        options,
+        setConfusedManifest() { },
+        setResolved() { },
+        maybeSetConfusedManifest() { },
+        workspaces: undefined,
+        toJSON() {
+            return {
+                id: this.id,
+                name: this.name,
+                version: this.version,
+                location: this.location,
+                importer: this.importer,
+                manifest: this.manifest,
+                projectRoot: this.projectRoot,
+                integrity: this.integrity,
+                resolved: this.resolved,
+                dev: this.dev,
+                optional: this.optional,
+                confused: false,
+            };
+        },
+    };
+    // @ts-expect-error
+    res[Symbol.toStringTag] = '@vltpkg/graph.Node';
+    // link all mainImporters to the virtual root
+    for (const importer of mainImporters) {
+        const name = importer.name || '(unknown)';
+        if (importer.mainImporter) {
+            const spec = Spec.parse(name, 'file:.', options);
+            const edge = {
+                name: spec.name,
+                from: res,
+                to: importer,
+                spec,
+                type: 'prod',
+            };
+            res.edgesOut.set(name, edge);
+            importer.edgesIn.add(edge);
+        }
+    }
+    return res;
+};

package/dist/visualization/human-readable-output.d.ts

@@ -0,0 +1,26 @@
+import type { EdgeLike, NodeLike } from '@vltpkg/types';
+export type TreeItem = {
+    name?: string | null;
+    edge: EdgeLike | undefined;
+    node: NodeLike | undefined;
+    prefix: string;
+    padding: string;
+    hasSibling: boolean;
+    seen: boolean;
+    include: boolean;
+    parent: TreeItem | undefined;
+};
+export type HumanReadableOutputGraph = {
+    edges: EdgeLike[];
+    importers: Set<NodeLike>;
+    nodes: NodeLike[];
+    highlightSelection?: boolean;
+};
+export type EdgeMap = Map<NodeLike | undefined, TreeItem>;
+export type TreeMap = Map<EdgeLike | undefined, EdgeMap>;
+/**
+ * Returns a human-readable output of the graph.
+ */
+export declare function humanReadableOutput(options: HumanReadableOutputGraph, { colors }: {
+    colors?: boolean;
+}): string;