@salesforce/packaging 4.9.1 → 4.11.0

package/lib/interfaces/packagingInterfacesAndType.d.ts

@@ -8,6 +8,7 @@ import { ConvertResult } from '@salesforce/source-deploy-retrieve';
 import type { Package } from '@salesforce/types/metadata';
 import { PackageProfileApi } from '../package/packageProfileApi';
 import { PackageAncestryNode } from '../package/packageAncestry';
+import { VersionNumber } from '../package/versionNumber';
 import { PackagingSObjects } from './packagingSObjects';
 import Package2VersionStatus = PackagingSObjects.Package2VersionStatus;
 import PackageInstallRequest = PackagingSObjects.PackageInstallRequest;
@@ -198,6 +199,7 @@ export type PackageVersionCreateRequest = {
     CalculateCodeCoverage: boolean;
     SkipValidation: boolean;
     AsyncValidation?: boolean;
+    CalcTransitiveDependencies?: boolean;
 };
 export type PackageVersionListOptions = {
     orderBy?: string;
@@ -399,6 +401,27 @@ export type AncestryRepresentationProducer = {
     addNode(node: AncestryRepresentationProducer): void;
     produce(): PackageAncestryNodeData | string | void;
 };
+export type PackageVersionDependencyOptions = {
+    packageVersionId: string;
+    project?: SfProject;
+    connection: Connection;
+    verbose?: boolean;
+    edgeDirection?: 'root-first' | 'root-last';
+};
+export type DependencyGraphData = {
+    creator: string;
+    nodes: DependencyGraphNode[];
+    edges: DependencyGraphEdge[];
+};
+export type DependencyGraphNode = {
+    subscriberPackageVersionId: string;
+    packageName: string;
+    version: VersionNumber;
+};
+export type DependencyGraphEdge = {
+    source: string;
+    target: string;
+};
 export declare const PackageEvents: {
     convert: {
         success: string;

package/lib/package/package.d.ts

@@ -1,6 +1,7 @@
 import { Connection, SfProject } from '@salesforce/core';
 import { ConvertPackageOptions, PackageCreateOptions, PackageOptions, PackageSaveResult, PackageType, PackageUpdateOptions, PackageVersionCreateRequestResult, PackageVersionListOptions, PackageVersionListResult, PackageVersionMetadataDownloadOptions, PackageVersionMetadataDownloadResult, PackagingSObjects } from '../interfaces';
 import { PackageAncestry } from './packageAncestry';
+import { PackageVersionDependency } from './packageVersionDependency';
 export declare const Package2Fields: string[];
 /**
  * Provides the ability to list, create, update, delete, convert, and get version
@@ -60,6 +61,18 @@ export declare class Package {
      * @param connection Hub Org Connection
      */
     static getAncestry(packageId: string, project: SfProject | undefined, connection: Connection): Promise<PackageAncestry>;
+    /**
+     * create a PackageVersionDependency instance
+     *
+     * @param packageVersionId to get version information for
+     * @param project SfProject instance
+     * @param connection Hub Org Connection
+     * @param options flags for the command line
+     */
+    static getDependencyGraph(packageVersionId: string, project: SfProject | undefined, connection: Connection, options?: {
+        verbose?: boolean;
+        edgeDirection?: 'root-first' | 'root-last';
+    }): Promise<PackageVersionDependency>;
     /**
      * Convert a 1st generation package to a 2nd generation package.
      * See {@link ConvertPackageOptions} for conversion options.

package/lib/package/package.js

@@ -9,6 +9,7 @@ const packageVersionRetrieve_1 = require("./packageVersionRetrieve");
 const packageVersionList_1 = require("./packageVersionList");
 const packageDelete_1 = require("./packageDelete");
 const packageAncestry_1 = require("./packageAncestry");
+const packageVersionDependency_1 = require("./packageVersionDependency");
 const packagePrefixes = {
     PackageId: '0Ho',
     SubscriberPackageVersionId: '04t',
@@ -136,6 +137,23 @@ class Package {
             connection,
         });
     }
+    /**
+     * create a PackageVersionDependency instance
+     *
+     * @param packageVersionId to get version information for
+     * @param project SfProject instance
+     * @param connection Hub Org Connection
+     * @param options flags for the command line
+     */
+    static async getDependencyGraph(packageVersionId, project, connection, options) {
+        return packageVersionDependency_1.PackageVersionDependency.create({
+            packageVersionId,
+            project,
+            connection,
+            verbose: options?.verbose ?? false,
+            edgeDirection: options?.edgeDirection ?? 'root-first',
+        });
+    }
     /**
      * Convert a 1st generation package to a 2nd generation package.
      * See {@link ConvertPackageOptions} for conversion options.

package/lib/package/packageVersionCreate.d.ts

@@ -26,6 +26,7 @@ export declare class PackageVersionCreate {
     private validateDependencyValues;
     private resolveBuildNumber;
     private createRequestObject;
+    private stripUnsupportedPropertiesBasedOnApiVersion;
     /**
      * Convert the list of command line options to a JSON object that can be used to create an Package2VersionCreateRequest entity.
      *

package/lib/package/packageVersionCreate.js

@@ -241,25 +241,10 @@ class PackageVersionCreate {
             CalculateCodeCoverage: this.options.codecoverage ?? false,
             SkipValidation: this.options.skipvalidation ?? false,
             AsyncValidation: this.options.asyncvalidation ?? false,
-            // note: the createRequest's Language corresponds to the AllPackageVersion's language
-            Language: this.options.language,
+            Language: this.options.language, // note: the createRequest's Language corresponds to the AllPackageVersion's language
+            CalcTransitiveDependencies: this.packageObject.calculateTransitiveDependencies ?? false,
         };
-        // Ensure we only include the Language property for a connection api version
-        // of v57.0 or higher.
-        if (this.connection.getApiVersion() < '57.0') {
-            if (requestObject.Language) {
-                this.logger.warn(`The language option is only valid for API version 57.0 and higher. Ignoring ${requestObject.Language}`);
-            }
-            delete requestObject.Language;
-        }
-        // Ensure we only include the async validation property for a connection api version
-        // of v60.0 or higher.
-        if (this.connection.getApiVersion() <= '60.0') {
-            if (requestObject.AsyncValidation) {
-                this.logger.warn(`The async validation option is only valid for API version 60.0 and higher. Ignoring ${requestObject.AsyncValidation}`);
-            }
-            delete requestObject.AsyncValidation;
-        }
+        this.stripUnsupportedPropertiesBasedOnApiVersion(requestObject);
         if (preserveFiles) {
             const message = messages.getMessage('tempFileLocation', [packageVersTmpRoot]);
             await core_1.Lifecycle.getInstance().emit(interfaces_1.PackageVersionEvents.create['preserve-files'], {
@@ -273,6 +258,27 @@ class PackageVersionCreate {
             return node_fs_1.default.promises.rm(packageVersTmpRoot, { recursive: true, force: true }).then(() => requestObject);
         }
     }
+    // TODO: W-18696754 - None of the logger.warn() calls work, nothing is printed to the console when they're hit.
+    stripUnsupportedPropertiesBasedOnApiVersion(requestObject) {
+        if (this.connection.getApiVersion() < '57.0') {
+            if (requestObject.Language) {
+                this.logger.warn(`The language option is only valid for API version 57.0 and higher. Ignoring ${requestObject.Language}`);
+            }
+            delete requestObject.Language;
+        }
+        if (this.connection.getApiVersion() < '60.0') {
+            if (requestObject.AsyncValidation) {
+                this.logger.warn(`The async validation option is only valid for API version 60.0 and higher. Ignoring ${requestObject.AsyncValidation}`);
+            }
+            delete requestObject.AsyncValidation;
+        }
+        if (this.connection.getApiVersion() < '65.0') {
+            if (requestObject.CalcTransitiveDependencies) {
+                this.logger.warn(`The CalculateTransitiveDependencies option is only valid for API version 65.0 and higher. Ignoring ${requestObject.CalcTransitiveDependencies}`);
+            }
+            delete requestObject.CalcTransitiveDependencies;
+        }
+    }
     /**
      * Convert the list of command line options to a JSON object that can be used to create an Package2VersionCreateRequest entity.
      *

package/lib/package/packageVersionDependency.d.ts

@@ -0,0 +1,80 @@
+import { Connection } from '@salesforce/core';
+import { AsyncCreatable } from '@salesforce/kit';
+import { PackageVersionDependencyOptions, DependencyGraphNode } from '../interfaces';
+import { VersionNumber } from './versionNumber';
+export declare const VERSION_BEING_BUILT = "VERSION_BEING_BUILT";
+export declare class PackageVersionDependency extends AsyncCreatable<PackageVersionDependencyOptions> {
+    options: PackageVersionDependencyOptions;
+    private connection;
+    private project?;
+    private userPackageVersionId;
+    private verbose;
+    private edgeDirection;
+    private resolvedPackageVersionId;
+    constructor(options: PackageVersionDependencyOptions);
+    init(): Promise<void>;
+    /**
+     * Returns a DependencyDotProducer that can be used to produce a DOT code representation of the package dependency graph.
+     */
+    getDependencyDotProducer(): Promise<DependencyDotProducer>;
+    /**
+     * Resolves id input to a 08c. User can input a 08c or 04t.
+     * Currently a 04t is not supported in filtering the Package2VersionCreateRequest. So a user's input of 04t will be resolved to a 05i and then a 08c.
+     */
+    private resolvePackageCreateRequestId;
+    private query05iFrom04t;
+    private query08cFrom05i;
+    /**
+     * Checks that the given Package2VersionCreateRequest ID (08c) contains a valid DependencyGraphJson to generate DOT code
+     */
+    private validatePackageVersion;
+    private verifyCreateRequesIdExistsOnDevHub;
+    private verifyTransitiveDependenciesCalculated;
+}
+export declare class DependencyDotProducer {
+    private dependencyGraphString;
+    private verbose;
+    private edgeDirection;
+    private resolvedPackageVersionId;
+    private subscriberPackageVersionId;
+    private connection;
+    private dependencyGraphData;
+    constructor(connection: Connection, dependencyGraphString: string, verbose: boolean, edgeDirection: 'root-first' | 'root-last', resolvedPackageVersionId: string);
+    private static throwErrorOnInvalidRecord;
+    init(): Promise<void>;
+    produce(): string;
+    private createDependencyGraphNodes;
+    /**
+     * Creates a single dependency graph node.
+     * All nodes in the json are 04t... or VERSION_BEING_BUILT and requires different queries to create the node
+     */
+    private createSingleDependencyGraphNode;
+    private createVersionBeingBuiltNode;
+    private createNormalDependencyNode;
+    private createDependencyGraphEdges;
+    /**
+     * Builds a DOT node with a label containing the package name and version
+     *
+     * @param node the node id and label
+     */
+    private buildDotNode;
+    /**
+     * Builds a DOT edge line of the form fromNode -> toNode
+     *
+     * @param edge the edge to build where the target node depends on the source node in the json
+     */
+    private buildDotEdge;
+}
+/**
+ * A class that represents a package dependency node.
+ * Given a PackageRequestId (08c), PackageName, SubscriberPackageVersionId (04t), and version (MajorVersion.MinorVersion.PatchVersion.BuildNumber) it will build a node of the package dependency.
+ */
+export declare class PackageDependencyNode extends AsyncCreatable<DependencyGraphNode> {
+    options: DependencyGraphNode;
+    readonly packageName: string;
+    readonly subscriberPackageVersionId: string;
+    readonly version: VersionNumber;
+    constructor(options: DependencyGraphNode);
+    getVersion(): string;
+    protected init(): Promise<void>;
+}

package/lib/package/packageVersionDependency.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageDependencyNode = exports.DependencyDotProducer = exports.PackageVersionDependency = exports.VERSION_BEING_BUILT = void 0;
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const node_os_1 = require("node:os");
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const versionNumber_1 = require("./versionNumber");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'package_version_dependency');
+exports.VERSION_BEING_BUILT = 'VERSION_BEING_BUILT';
+const SELECT_PACKAGE_VERSION_DEPENDENCY = 'SELECT CalcTransitiveDependencies, DependencyGraphJson FROM Package2VersionCreateRequest';
+class PackageVersionDependency extends kit_1.AsyncCreatable {
+    options;
+    connection;
+    project;
+    userPackageVersionId;
+    verbose;
+    edgeDirection;
+    resolvedPackageVersionId;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.connection = options.connection;
+        this.project = options.project;
+        this.userPackageVersionId = options.packageVersionId;
+        this.verbose = options.verbose ?? false;
+        this.edgeDirection = options.edgeDirection ?? 'root-first';
+        this.resolvedPackageVersionId = '';
+    }
+    async init() {
+        await this.resolvePackageCreateRequestId();
+    }
+    /**
+     * Returns a DependencyDotProducer that can be used to produce a DOT code representation of the package dependency graph.
+     */
+    async getDependencyDotProducer() {
+        const isValid = await this.validatePackageVersion();
+        if (!isValid) {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+        const query = `${SELECT_PACKAGE_VERSION_DEPENDENCY} WHERE Id = '${this.resolvedPackageVersionId}'`;
+        const result = await this.connection.tooling.query(query);
+        const dependencyGraphJson = result.records[0].DependencyGraphJson;
+        // validatePackageVersion() should have already ensured this is not null
+        if (!dependencyGraphJson) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        const producer = new DependencyDotProducer(this.connection, dependencyGraphJson, this.verbose, this.edgeDirection, this.resolvedPackageVersionId);
+        await producer.init();
+        return producer;
+    }
+    /**
+     * Resolves id input to a 08c. User can input a 08c or 04t.
+     * Currently a 04t is not supported in filtering the Package2VersionCreateRequest. So a user's input of 04t will be resolved to a 05i and then a 08c.
+     */
+    async resolvePackageCreateRequestId() {
+        const versionId = this.project?.getPackageIdFromAlias(this.userPackageVersionId) ?? this.userPackageVersionId;
+        // User provided a Package2VersionCreateRequest ID (08c) and doesn't need to be resolved
+        if (versionId.startsWith('08c')) {
+            this.resolvedPackageVersionId = versionId;
+        }
+        // User provided a SubscriberPackageVersionId (04t) and needs to be resolved to a Package2VersionCreateRequest ID (08c)
+        else if (versionId.startsWith('04t')) {
+            const package2VersionId = await this.query05iFrom04t(versionId);
+            this.resolvedPackageVersionId = await this.query08cFrom05i(package2VersionId);
+        }
+        else {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+    }
+    async query05iFrom04t(package04t) {
+        const query05i = `SELECT Id FROM Package2Version WHERE SubscriberPackageVersionId = '${package04t}'`;
+        const result05i = await this.connection.tooling.query(query05i);
+        if (result05i.records?.length !== 1) {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+        return result05i.records[0].Id;
+    }
+    async query08cFrom05i(package05i) {
+        const query08c = `SELECT Id FROM Package2VersionCreateRequest WHERE Package2VersionId = '${package05i}'`;
+        const result08c = await this.connection.tooling.query(query08c);
+        if (result08c.records?.length !== 1) {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+        return result08c.records[0].Id;
+    }
+    /**
+     * Checks that the given Package2VersionCreateRequest ID (08c) contains a valid DependencyGraphJson to generate DOT code
+     */
+    async validatePackageVersion() {
+        if (!this.resolvedPackageVersionId) {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+        if (await this.verifyTransitiveDependenciesCalculated()) {
+            return true;
+        }
+        return false;
+    }
+    async verifyCreateRequesIdExistsOnDevHub() {
+        const query = `${SELECT_PACKAGE_VERSION_DEPENDENCY} WHERE Id = '${this.resolvedPackageVersionId}'`;
+        const result = await this.connection.tooling.query(query);
+        if (result.records?.length === 0) {
+            throw messages.createError('invalidPackageVersionIdError', [this.userPackageVersionId]);
+        }
+        return true;
+    }
+    async verifyTransitiveDependenciesCalculated() {
+        if (await this.verifyCreateRequesIdExistsOnDevHub()) {
+            const query = `${SELECT_PACKAGE_VERSION_DEPENDENCY} WHERE Id = '${this.resolvedPackageVersionId}'`;
+            const result = await this.connection.tooling.query(query);
+            if (result.records?.length === 1) {
+                const record = result.records[0];
+                if (record.CalcTransitiveDependencies === true) {
+                    if (record.DependencyGraphJson != null) {
+                        return true;
+                    }
+                    else {
+                        throw messages.createError('invalidDependencyGraphError');
+                    }
+                }
+                else {
+                    throw messages.createError('transitiveDependenciesRequiredError');
+                }
+            }
+        }
+        return false;
+    }
+}
+exports.PackageVersionDependency = PackageVersionDependency;
+class DependencyDotProducer {
+    dependencyGraphString;
+    verbose;
+    edgeDirection;
+    resolvedPackageVersionId;
+    subscriberPackageVersionId;
+    connection;
+    dependencyGraphData;
+    constructor(connection, dependencyGraphString, verbose, edgeDirection, resolvedPackageVersionId) {
+        this.verbose = verbose;
+        this.edgeDirection = edgeDirection;
+        this.resolvedPackageVersionId = resolvedPackageVersionId;
+        this.connection = connection;
+        this.dependencyGraphString = dependencyGraphString;
+        this.subscriberPackageVersionId = exports.VERSION_BEING_BUILT;
+    }
+    static throwErrorOnInvalidRecord(record) {
+        if (!Object.values(record).every((value) => value !== null)) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+    }
+    async init() {
+        const dependencyGraphJson = JSON.parse(this.dependencyGraphString);
+        this.dependencyGraphData = {
+            creator: dependencyGraphJson.creator,
+            nodes: await this.createDependencyGraphNodes(dependencyGraphJson.nodes),
+            edges: this.createDependencyGraphEdges(dependencyGraphJson.edges),
+        };
+    }
+    produce() {
+        const dotLines = [];
+        for (const node of this.dependencyGraphData.nodes) {
+            dotLines.push(this.buildDotNode(node));
+        }
+        for (const edge of this.dependencyGraphData.edges) {
+            dotLines.push(this.buildDotEdge(edge));
+        }
+        return `strict digraph G {${node_os_1.EOL}${dotLines.join(node_os_1.EOL)}${node_os_1.EOL}}`;
+    }
+    async createDependencyGraphNodes(jsonNodes) {
+        const nodePromises = jsonNodes.map(async (node) => this.createSingleDependencyGraphNode(node.id));
+        const resolvedNodes = await Promise.all(nodePromises);
+        return resolvedNodes;
+    }
+    /**
+     * Creates a single dependency graph node.
+     * All nodes in the json are 04t... or VERSION_BEING_BUILT and requires different queries to create the node
+     */
+    async createSingleDependencyGraphNode(nodeId) {
+        const isVersionBeingCreatedNode = nodeId === exports.VERSION_BEING_BUILT;
+        const isSubscriberPackageVersionId = nodeId.startsWith('04t');
+        if (!isVersionBeingCreatedNode && !isSubscriberPackageVersionId) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        if (isVersionBeingCreatedNode) {
+            return this.createVersionBeingBuiltNode(nodeId);
+        }
+        return this.createNormalDependencyNode(nodeId);
+    }
+    async createVersionBeingBuiltNode(nodeId) {
+        let subscriberPackageVersionId = nodeId;
+        let MajorVersion = 0;
+        let MinorVersion = 0;
+        let PatchVersion = 0;
+        let BuildNumber = 0;
+        const nodeQuery = `SELECT Package2Version.SubscriberPackageVersionId, Package2.Name, 
+      Package2Version.MajorVersion, Package2Version.MinorVersion, 
+      Package2Version.PatchVersion, Package2Version.BuildNumber 
+      FROM Package2VersionCreateRequest WHERE Id = '${this.resolvedPackageVersionId}'`;
+        const nodeResult = await this.connection.tooling.query(nodeQuery);
+        if (nodeResult.records?.length !== 1) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        const record = nodeResult.records[0];
+        if (!record.Package2?.Name) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        const packageName = record.Package2.Name;
+        // sets the version number correctly and version id to 04t if it exists
+        if (record.Package2Version?.SubscriberPackageVersionId) {
+            DependencyDotProducer.throwErrorOnInvalidRecord(record.Package2Version);
+            subscriberPackageVersionId = record.Package2Version.SubscriberPackageVersionId;
+            this.subscriberPackageVersionId = subscriberPackageVersionId;
+            MajorVersion = record.Package2Version.MajorVersion;
+            MinorVersion = record.Package2Version.MinorVersion;
+            PatchVersion = record.Package2Version.PatchVersion;
+            BuildNumber = record.Package2Version.BuildNumber;
+        }
+        return {
+            subscriberPackageVersionId,
+            packageName,
+            version: new versionNumber_1.VersionNumber(MajorVersion, MinorVersion, PatchVersion, BuildNumber),
+        };
+    }
+    async createNormalDependencyNode(nodeId) {
+        const subscriberPackageVersionId = nodeId;
+        const nodeQuery = `SELECT SubscriberPackageVersionId, Package2.Name, MajorVersion, MinorVersion, PatchVersion, BuildNumber 
+      FROM Package2Version WHERE SubscriberPackageVersionId = '${nodeId}'`;
+        const nodeResult = await this.connection.tooling.query(nodeQuery);
+        if (nodeResult.records?.length !== 1) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        const record = nodeResult.records[0];
+        DependencyDotProducer.throwErrorOnInvalidRecord(record);
+        return {
+            subscriberPackageVersionId,
+            packageName: record.Package2.Name,
+            version: new versionNumber_1.VersionNumber(record.MajorVersion, record.MinorVersion, record.PatchVersion, record.BuildNumber),
+        };
+    }
+    createDependencyGraphEdges(jsonEdges) {
+        const edges = [];
+        for (const edge of jsonEdges) {
+            let source = edge.source;
+            let target = edge.target;
+            if (!source || !target) {
+                throw messages.createError('invalidDependencyGraphError');
+            }
+            if (source === exports.VERSION_BEING_BUILT) {
+                source = this.subscriberPackageVersionId;
+            }
+            if (target === exports.VERSION_BEING_BUILT) {
+                target = this.subscriberPackageVersionId;
+            }
+            edges.push({ source, target });
+        }
+        return edges;
+    }
+    /**
+     * Builds a DOT node with a label containing the package name and version
+     *
+     * @param node the node id and label
+     */
+    buildDotNode(node) {
+        const nodeId = node.subscriberPackageVersionId;
+        let label;
+        // Include subscriber package version id in label based on verbose flag
+        if (node.subscriberPackageVersionId === exports.VERSION_BEING_BUILT) {
+            label = `${node.packageName}@${exports.VERSION_BEING_BUILT}`;
+        }
+        else {
+            label = `${node.packageName}@${node.version.toString()}`;
+        }
+        if (this.verbose) {
+            label += ` (${node.subscriberPackageVersionId})`;
+        }
+        return `\t node_${nodeId} [label="${label}"]`;
+    }
+    /**
+     * Builds a DOT edge line of the form fromNode -> toNode
+     *
+     * @param edge the edge to build where the target node depends on the source node in the json
+     */
+    buildDotEdge(edge) {
+        const sourceNodeId = edge.source;
+        const targetNodeId = edge.target;
+        if (!sourceNodeId || !targetNodeId) {
+            throw messages.createError('invalidDependencyGraphError');
+        }
+        // Handle edge direction based on the flag
+        if (this.edgeDirection === 'root-last') {
+            return `\t node_${sourceNodeId} -> node_${targetNodeId}`;
+        }
+        return `\t node_${targetNodeId} -> node_${sourceNodeId}`;
+    }
+}
+exports.DependencyDotProducer = DependencyDotProducer;
+/**
+ * A class that represents a package dependency node.
+ * Given a PackageRequestId (08c), PackageName, SubscriberPackageVersionId (04t), and version (MajorVersion.MinorVersion.PatchVersion.BuildNumber) it will build a node of the package dependency.
+ */
+class PackageDependencyNode extends kit_1.AsyncCreatable {
+    options;
+    packageName;
+    subscriberPackageVersionId;
+    version;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.packageName = options.packageName;
+        this.subscriberPackageVersionId = options.subscriberPackageVersionId;
+        this.version = new versionNumber_1.VersionNumber(this.options.version.major, this.options.version.minor, this.options.version.patch, this.options.version.build);
+    }
+    getVersion() {
+        return this.version.toString();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    init() {
+        return Promise.resolve();
+    }
+}
+exports.PackageDependencyNode = PackageDependencyNode;
+//# sourceMappingURL=packageVersionDependency.js.map

package/messages/package_version_dependency.md

@@ -0,0 +1,11 @@
+# invalidPackageVersionIdError
+
+Can't display package dependencies. The package version ID %s you specified is invalid. Review the package version ID and then retry this command.
+
+# transitiveDependenciesRequiredError
+
+Can't display package dependencies. To display package dependencies, you must first add the calculateTransitiveDependencies parameter to the sfdx-project.json file, and set the value to "true". Next, create a new package version and then run this command using the 04t ID for the new package version.
+
+# invalidDependencyGraphError
+
+Can't display package dependencies. There's an issue generating the dependency graph. Before retrying this command, make sure you added the calculateTransitiveDependencies parameter to the sfdx-project.json file and set the value to "true". After setting the attribute and before retrying this command, you must create a new package version.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/packaging",
-  "version": "4.9.1",
+  "version": "4.11.0",
   "description": "Packaging library for the Salesforce packaging platform",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -43,7 +43,7 @@
   ],
   "dependencies": {
     "@jsforce/jsforce-node": "^3.6.5",
-    "@salesforce/core": "^8.15.0",
+    "@salesforce/core": "^8.18.5",
     "@salesforce/kit": "^3.2.3",
     "@salesforce/schemas": "^1.9.1",
     "@salesforce/source-deploy-retrieve": "^12.16.9",