@salesforce/packaging 0.0.29 → 0.0.32

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.32](https://github.com/forcedotcom/packaging/compare/v0.0.31...v0.0.32) (2022-09-07)
+
+### Bug Fixes
+
+- add Package.uninstallReport method, NUT ([9269c9b](https://github.com/forcedotcom/packaging/commit/9269c9b999dcac25ac52c4ee64bf261ffebfb0e0))
+
+### [0.0.31](https://github.com/forcedotcom/packaging/compare/v0.0.30...v0.0.31) (2022-09-07)
+
+### Bug Fixes
+
+- add Package2.IsOrgDependent to select query ([8f013ef](https://github.com/forcedotcom/packaging/commit/8f013ef602c76990fa8649b585214991c8afe2c0))
+
+### [0.0.30](https://github.com/forcedotcom/packaging/compare/v0.0.29...v0.0.30) (2022-08-29)
+
+### Bug Fixes
+
+- add Package.update method, NUT ([dd77095](https://github.com/forcedotcom/packaging/commit/dd77095f77d2224c347d146810f8d0f883bbd9a3))
+
 ### [0.0.29](https://github.com/forcedotcom/packaging/compare/v0.0.28...v0.0.29) (2022-08-26)
 
 ### Bug Fixes

package/lib/interfaces/packagingInterfacesAndType.d.ts

@@ -1,7 +1,9 @@
 import { Duration } from '@salesforce/kit';
 import { Connection, NamedPackageDir, SfProject } from '@salesforce/core';
 import { QueryResult, SaveResult } from 'jsforce';
+import { Attributes } from 'graphology-types';
 import { PackageProfileApi } from '../package/packageProfileApi';
+import { PackageAncestryNode } from '../package/packageAncestry';
 import { PackagingSObjects } from './packagingSObjects';
 import Package2VersionStatus = PackagingSObjects.Package2VersionStatus;
 import PackageInstallRequest = PackagingSObjects.PackageInstallRequest;
@@ -14,7 +16,7 @@ export interface IPackage {
     getInstallStatus(installRequestId: string): Promise<PackageInstallRequest>;
     list(): Promise<QueryResult<PackagingSObjects.Package2>>;
     uninstall(): Promise<void>;
-    update(): Promise<void>;
+    update(options: PackageUpdateOptions): Promise<PackageSaveResult>;
     waitForPublish(subscriberPackageVersionKey: string, timeout: number | Duration, installationKey?: string): any;
     getExternalSites(subscriberPackageVersionKey: string, installationKey?: string): any;
 }
@@ -39,6 +41,12 @@ export interface IPackageVersion2GP {
 export declare type PackageOptions = {
     connection: Connection;
 };
+export declare type PackageUpdateOptions = {
+    Id: string;
+    Name?: string;
+    Description?: string;
+    PackageErrorUsername?: string;
+};
 export declare type PackageIdType = 'PackageId' | 'SubscriberPackageVersionId' | 'PackageInstallRequestId' | 'PackageUninstallRequestId';
 export declare type PackageVersionOptions1GP = Record<string, unknown>;
 export declare type PackageVersionCreateRequestResult = {
@@ -263,3 +271,34 @@ export declare type CodeCoveragePercentages = null | {
         }
     ];
 };
+export declare type PackageAncestryNodeOptions = Attributes & {
+    AncestorId?: string;
+    SubscriberPackageVersionId?: string;
+    MajorVersion?: string | number;
+    MinorVersion?: string | number;
+    PatchVersion?: string | number;
+    BuildNumber?: string | number;
+    depthCounter?: number;
+};
+export declare type PackageAncestryData = Omit<PackageAncestryNodeOptions, 'AncestorId'>;
+export declare type PackageAncestryNodeData = {
+    data: PackageAncestryNodeOptions;
+    children: PackageAncestryNodeData[];
+};
+export declare type PackageAncestryOptions = {
+    packageId: string;
+    project: SfProject;
+    connection: Connection;
+};
+export declare type AncestryRepresentationProducerOptions = {
+    [key: string]: unknown;
+    node: PackageAncestryNode;
+    depth?: number;
+    verbose?: boolean;
+};
+export interface AncestryRepresentationProducer {
+    label: string;
+    options: AncestryRepresentationProducerOptions;
+    addNode(node: AncestryRepresentationProducer): void;
+    produce<T>(): T | string | void;
+}

package/lib/interfaces/packagingSObjects.d.ts

@@ -175,7 +175,7 @@ export declare namespace PackagingSObjects {
         LastModifiedById: string;
         SystemModstamp: number;
         SubscriberPackageVersionId: string;
-        Status: string;
+        Status: 'Error' | 'InProgress' | 'Queued' | 'Success';
     };
     type PackageVersionUninstallRequestError = {
         Id: string;

package/lib/package/index.d.ts

@@ -9,3 +9,4 @@ export { deletePackage } from './packageDelete';
 export { uninstallPackage } from './packageUninstall';
 export * from './packageInstalledList';
 export * from './packageVersionCreateRequestReport';
+export * from './packageAncestry';

package/lib/package/index.js

@@ -36,4 +36,5 @@ var packageUninstall_1 = require("./packageUninstall");
 Object.defineProperty(exports, "uninstallPackage", { enumerable: true, get: function () { return packageUninstall_1.uninstallPackage; } });
 __exportStar(require("./packageInstalledList"), exports);
 __exportStar(require("./packageVersionCreateRequestReport"), exports);
+__exportStar(require("./packageAncestry"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/package.d.ts

@@ -1,7 +1,7 @@
 import { AsyncCreatable, Duration } from '@salesforce/kit';
 import { QueryResult } from 'jsforce';
 import { Optional } from '@salesforce/ts-types';
-import { IPackage, PackageOptions, PackagingSObjects, PackageInstallOptions, PackageInstallCreateRequest, PackageIdType } from '../interfaces';
+import { IPackage, PackageOptions, PackagingSObjects, PackageInstallOptions, PackageInstallCreateRequest, PackageIdType, PackageSaveResult, PackageUpdateOptions } from '../interfaces';
 declare type PackageInstallRequest = PackagingSObjects.PackageInstallRequest;
 /**
  * Package class.
@@ -32,7 +32,13 @@ export declare class Package extends AsyncCreatable<PackageOptions> implements I
     getInstallStatus(installRequestId: string): Promise<PackageInstallRequest>;
     list(): Promise<QueryResult<PackagingSObjects.Package2>>;
     uninstall(): Promise<void>;
-    update(): Promise<void>;
+    /**
+     * Reports on the uninstall progress of a package.
+     *
+     * @param id the 06y package uninstall request id
+     */
+    uninstallReport(id: string): Promise<PackagingSObjects.SubscriberPackageVersionUninstallRequest>;
+    update(options: PackageUpdateOptions): Promise<PackageSaveResult>;
     getPackage(packageId: string): Promise<PackagingSObjects.Package2>;
     getExternalSites(subscriberPackageVersionId: string, installationKey?: string): Promise<Optional<string[]>>;
     waitForPublish(subscriberPackageVersionId: string, timeout: number | Duration, installationKey?: string): Promise<void>;

package/lib/package/package.js

@@ -72,8 +72,33 @@ class Package extends kit_1.AsyncCreatable {
     uninstall() {
         return Promise.resolve(undefined);
     }
-    update() {
-        return Promise.resolve(undefined);
+    /**
+     * Reports on the uninstall progress of a package.
+     *
+     * @param id the 06y package uninstall request id
+     */
+    async uninstallReport(id) {
+        const result = (await this.options.connection.tooling.retrieve('SubscriberPackageVersionUninstallRequest', id));
+        if (result.Status === 'Error') {
+            const errorDetails = await this.options.connection.tooling.query(`SELECT Message FROM PackageVersionUninstallRequestError WHERE ParentRequest.Id = '${id}' ORDER BY Message`);
+            const errors = [];
+            errorDetails.records.forEach((record) => {
+                errors.push(`(${errors.length + 1}) ${record.Message}`);
+            });
+            const errHeader = errors.length > 0 ? `\n=== Errors\n${errors.join('\n')}` : '';
+            const err = messages.getMessage('defaultErrorMessage', [id, result.Id]);
+            throw new core_1.SfError(`${err}${errHeader}`, 'UNINSTALL_ERROR', [messages.getMessage('action')]);
+        }
+        return result;
+    }
+    async update(options) {
+        // filter out any undefined values and their keys
+        Object.keys(options).forEach((key) => options[key] === undefined && delete options[key]);
+        const result = await this.options.connection.tooling.update('Package2', options);
+        if (!result.success) {
+            throw new core_1.SfError(result.errors.join(', '));
+        }
+        return result;
     }
     async getPackage(packageId) {
         const package2 = await this.options.connection.tooling.sobject('Package2').retrieve(packageId);

package/lib/package/packageAncestry.d.ts

@@ -0,0 +1,111 @@
+import { DirectedGraph } from 'graphology';
+import { AsyncCreatable } from '@salesforce/kit';
+import { Tree } from '@oclif/core/lib/cli-ux/styled/tree';
+import { Attributes } from 'graphology-types';
+import { AncestryRepresentationProducer, AncestryRepresentationProducerOptions, PackageAncestryNodeOptions, PackageAncestryOptions } from '../interfaces';
+import { VersionNumber } from '../utils/versionNumber';
+/**
+ * A class that represents the package ancestry graph.
+ */
+export declare class PackageAncestry extends AsyncCreatable<PackageAncestryOptions> {
+    private options;
+    private _requestedPackageId;
+    private graph;
+    private roots;
+    constructor(options: PackageAncestryOptions);
+    get requestedPackageId(): string;
+    init(): Promise<void>;
+    /**
+     * Returns the internal representation of the requested package ancestry graph.
+     */
+    getAncestryGraph(): DirectedGraph<Attributes, Attributes, Attributes>;
+    /**
+     * Convenience method to get the json representation of the package ancestry graph.
+     */
+    getJsonProducer(): Promise<AncestryRepresentationProducer>;
+    /**
+     * Convenience method to get the CliUx.Tree representation of the package ancestry graph.
+     */
+    getTreeProducer(verbose: boolean): Promise<AncestryRepresentationProducer>;
+    /**
+     * Convenience method to get the dot representation of the package ancestry graph.
+     */
+    getDotProducer(): Promise<AncestryRepresentationProducer>;
+    /**
+     * Returns the producer representation of the package ancestry graph.
+     *
+     * @param producerCtor - function that returns a new instance of the producer
+     * @param root - the subscriber package version id of the root node
+     */
+    getRepresentationProducer(producerCtor: (options?: AncestryRepresentationProducerOptions) => AncestryRepresentationProducer, root: string | undefined): Promise<AncestryRepresentationProducer>;
+    /**
+     * Returns a list of ancestry nodes that represent the path from subscriber package version id to the root of the
+     * package ancestry tree.
+     *
+     * @param subscriberPackageVersionId
+     */
+    getLeafPathToRoot(subscriberPackageVersionId?: string): Promise<PackageAncestryNode[][]>;
+    private buildAncestryTree;
+    private getRoots;
+    private findRootsForPackageVersion;
+    private getPackageVersion;
+    private findRootsForPackage;
+    private buildAncestryTreeFromRoots;
+    private addDescendantsFromPackageVersion;
+    private addToGraph;
+    private getDescendants;
+}
+export declare class AncestryTreeProducer extends Tree implements AncestryRepresentationProducer {
+    label: string;
+    options: AncestryRepresentationProducerOptions;
+    private verbose;
+    constructor(options?: AncestryRepresentationProducerOptions);
+    addNode(node: AncestryTreeProducer): void;
+    produce(): void;
+    private createLabel;
+}
+export declare class AncestryJsonProducer implements AncestryRepresentationProducer {
+    label: string;
+    options: AncestryRepresentationProducerOptions;
+    private children;
+    private readonly data;
+    constructor(options?: AncestryRepresentationProducerOptions);
+    addNode(node: AncestryJsonProducer): void;
+    produce<PackageAncestryNodeData>(): PackageAncestryNodeData;
+}
+export declare class AncestryDotProducer implements AncestryRepresentationProducer {
+    label: string;
+    options: AncestryRepresentationProducerOptions;
+    private children;
+    constructor(options?: AncestryRepresentationProducerOptions);
+    /**
+     * Builds a node line in DOT, of the form nodeID [label="MAJOR.MINOR.PATCH"]
+     *
+     * @param currentNode
+     */
+    static buildDotNode(currentNode: AncestryDotProducer): string;
+    /**
+     * Builds an edge line in DOT, of the form fromNode -- toNode
+     *
+     * @param fromNode
+     * @param toNode
+     */
+    static buildDotEdge(fromNode: AncestryDotProducer, toNode: AncestryDotProducer): string;
+    addNode(node: AncestryDotProducer): void;
+    produce(): string;
+}
+export declare class PackageAncestryNode extends AsyncCreatable<PackageAncestryNodeOptions> implements Attributes {
+    #private;
+    options: PackageAncestryNodeOptions;
+    constructor(options: PackageAncestryNodeOptions);
+    get AncestorId(): string;
+    get SubscriberPackageVersionId(): string;
+    get version(): VersionNumber;
+    get MinorVersion(): number;
+    get PatchVersion(): number;
+    get BuildNumber(): number | string;
+    get MajorVersion(): number;
+    get depthCounter(): number;
+    getVersion(): string;
+    protected init(): Promise<void>;
+}

package/lib/package/packageAncestry.js

@@ -0,0 +1,432 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PackageAncestryNode_version, _PackageAncestryNode_MajorVersion, _PackageAncestryNode_MinorVersion, _PackageAncestryNode_PatchVersion, _PackageAncestryNode_BuildNumber, _PackageAncestryNode_AncestorId, _PackageAncestryNode_SubscriberPackageVersionId, _PackageAncestryNode_depthCounter;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageAncestryNode = exports.AncestryDotProducer = exports.AncestryJsonProducer = exports.AncestryTreeProducer = exports.PackageAncestry = 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 os_1 = require("os");
+const core_1 = require("@salesforce/core");
+const graphology_1 = require("graphology");
+const kit_1 = require("@salesforce/kit");
+const tree_1 = require("@oclif/core/lib/cli-ux/styled/tree");
+const graphology_traversal_1 = require("graphology-traversal");
+const pkgUtils = require("../utils/packageUtils");
+const versionNumber_1 = require("../utils/versionNumber");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const SELECT_PACKAGE_VERSION = 'SELECT AncestorId, SubscriberPackageVersionId, MajorVersion, MinorVersion, PatchVersion, BuildNumber FROM Package2Version';
+const SELECT_PACKAGE_CONTAINER_OPTIONS = 'SELECT ContainerOptions FROM Package2   ';
+const SELECT_PACKAGE_VERSION_CONTAINER_OPTIONS = 'SELECT Package2ContainerOptions FROM SubscriberPackageVersion';
+// Add this to query calls to only show released package versions in the output
+const releasedOnlyFilter = ' AND IsReleased = true';
+/**
+ * A class that represents the package ancestry graph.
+ */
+class PackageAncestry extends kit_1.AsyncCreatable {
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.graph = new graphology_1.DirectedGraph();
+    }
+    get requestedPackageId() {
+        return this._requestedPackageId;
+    }
+    async init() {
+        await this.buildAncestryTree();
+    }
+    /**
+     * Returns the internal representation of the requested package ancestry graph.
+     */
+    getAncestryGraph() {
+        return this.graph;
+    }
+    /**
+     * Convenience method to get the json representation of the package ancestry graph.
+     */
+    async getJsonProducer() {
+        return this.getRepresentationProducer((opts) => new AncestryJsonProducer(opts), this.requestedPackageId);
+    }
+    /**
+     * Convenience method to get the CliUx.Tree representation of the package ancestry graph.
+     */
+    async getTreeProducer(verbose) {
+        return this.getRepresentationProducer((opts) => new AncestryTreeProducer({ ...opts, verbose: !!verbose }), this.requestedPackageId);
+    }
+    /**
+     * Convenience method to get the dot representation of the package ancestry graph.
+     */
+    async getDotProducer() {
+        return this.getRepresentationProducer((opts) => new AncestryDotProducer(opts), this.requestedPackageId);
+    }
+    /**
+     * Returns the producer representation of the package ancestry graph.
+     *
+     * @param producerCtor - function that returns a new instance of the producer
+     * @param root - the subscriber package version id of the root node
+     */
+    async getRepresentationProducer(producerCtor, root) {
+        const treeRoot = root
+            ? this.graph.findNode((node, attributes) => attributes.node.SubscriberPackageVersionId === root)
+            : undefined;
+        const tree = producerCtor();
+        const treeStack = [];
+        function handleNode(node, attr, depth) {
+            if (treeStack.length > depth) {
+                treeStack.splice(depth);
+            }
+            let t = treeStack[depth];
+            if (!t) {
+                t = producerCtor({ node: attr.node, depth });
+                treeStack.push(t);
+            }
+            if (depth === 0) {
+                tree.addNode(t);
+            }
+            else {
+                treeStack[depth - 1].addNode(t);
+            }
+        }
+        if (treeRoot) {
+            (0, graphology_traversal_1.dfsFromNode)(this.graph, treeRoot, handleNode);
+        }
+        else {
+            (0, graphology_traversal_1.dfs)(this.graph, handleNode);
+        }
+        return tree;
+    }
+    /**
+     * Returns a list of ancestry nodes that represent the path from subscriber package version id to the root of the
+     * package ancestry tree.
+     *
+     * @param subscriberPackageVersionId
+     */
+    async getLeafPathToRoot(subscriberPackageVersionId) {
+        const root = this.graph.findNode((node, attributes) => attributes.node.AncestorId === null);
+        const paths = [];
+        let path = [];
+        let previousDepth = 0;
+        (0, graphology_traversal_1.dfsFromNode)(this.graph, root, function (node, attr, depth) {
+            if (depth === 0) {
+                paths.push(path);
+                path = [];
+            }
+            else if (depth <= previousDepth) {
+                paths.push(path);
+                path = path.slice(0, depth);
+            }
+            previousDepth = depth;
+            path.push(attr.node);
+        });
+        // push remaining path
+        paths.push(path);
+        return paths
+            .filter((path) => path.length > 0 && // don't care about zero length paths
+            (!subscriberPackageVersionId ||
+                path.some((node) => node.SubscriberPackageVersionId === subscriberPackageVersionId)))
+            .map((path) => path.reverse())
+            .map((path) => {
+            const subscriberPackageVersionIdIndex = path.findIndex((node) => node.SubscriberPackageVersionId === subscriberPackageVersionId);
+            return path.slice(subscriberPackageVersionIdIndex === -1 ? 0 : subscriberPackageVersionIdIndex);
+        });
+    }
+    async buildAncestryTree() {
+        this.roots = await this.getRoots();
+        await this.buildAncestryTreeFromRoots(this.roots);
+    }
+    async getRoots() {
+        let roots = [];
+        this._requestedPackageId = pkgUtils.getPackageIdFromAlias(this.options.packageId, this.options.project);
+        switch (this.requestedPackageId.slice(0, 3)) {
+            case '0Ho':
+                pkgUtils.validateId(pkgUtils.BY_LABEL.PACKAGE_ID, this.requestedPackageId);
+                roots = await this.findRootsForPackage();
+                break;
+            case '04t':
+                pkgUtils.validateId(pkgUtils.BY_LABEL.SUBSCRIBER_PACKAGE_VERSION_ID, this.requestedPackageId);
+                roots = await this.findRootsForPackageVersion();
+                break;
+            default:
+                throw messages.createError('idOrAliasNotFound', [this.requestedPackageId]);
+        }
+        return roots;
+    }
+    async findRootsForPackageVersion() {
+        // Check to see if the package version is part of an unlocked package
+        // if so, throw an error since ancestry only applies to managed packages
+        const versionQuery = `${SELECT_PACKAGE_VERSION_CONTAINER_OPTIONS} WHERE Id = '${this.requestedPackageId}'`;
+        const packageVersionTypeResults = await this.options.connection.singleRecordQuery(versionQuery, { tooling: true });
+        if (packageVersionTypeResults.Package2ContainerOptions !== 'Managed') {
+            throw messages.createError('unlockedPackageError');
+        }
+        // Start with the node, and shoot up
+        let node = await this.getPackageVersion(this.requestedPackageId);
+        while (node.AncestorId !== null) {
+            const ancestor = await this.getPackageVersion(node.AncestorId);
+            this.addToGraph(ancestor, node);
+            node = ancestor;
+        }
+        return [node];
+    }
+    async getPackageVersion(nodeId) {
+        const query = `${SELECT_PACKAGE_VERSION} WHERE SubscriberPackageVersionId = '${nodeId}'`;
+        try {
+            const results = await this.options.connection.singleRecordQuery(query, {
+                tooling: true,
+            });
+            return new PackageAncestryNode(results);
+        }
+        catch (e) {
+            if (e.message.includes('No record found for')) {
+                throw messages.createError('versionNotFound', [nodeId]);
+            }
+            throw e;
+        }
+    }
+    async findRootsForPackage() {
+        // Check to see if the package is an unlocked package
+        // if so, throw and error since ancestry only applies to managed packages
+        const query = `${SELECT_PACKAGE_CONTAINER_OPTIONS} WHERE Id = '${this.requestedPackageId}'`;
+        const packageTypeResults = await this.options.connection.tooling.query(query);
+        if (packageTypeResults?.records?.length === 0) {
+            throw messages.createError('invalidId', [this.requestedPackageId]);
+        }
+        else if (packageTypeResults?.records?.length && packageTypeResults?.records[0].ContainerOptions !== 'Managed') {
+            throw messages.createError('unlockedPackageError');
+        }
+        const normalQuery = `${SELECT_PACKAGE_VERSION} WHERE AncestorId = NULL AND Package2Id = '${this.requestedPackageId}' ${releasedOnlyFilter}`;
+        const subscriberPackageVersions = (await this.options.connection.tooling.query(normalQuery)).records?.map((record) => new PackageAncestryNode(record));
+        // The package exists, but there are no versions for the provided package
+        if (subscriberPackageVersions.length === 0) {
+            throw messages.createError('noVersionsError');
+        }
+        return subscriberPackageVersions;
+    }
+    async buildAncestryTreeFromRoots(roots) {
+        while (roots.length > 0) {
+            const subscriberPackageVersion = roots.shift();
+            const descendants = await this.addDescendantsFromPackageVersion(subscriberPackageVersion);
+            roots.push(...descendants);
+        }
+    }
+    async addDescendantsFromPackageVersion(subscriberPackageVersion) {
+        const descendants = await this.getDescendants(subscriberPackageVersion);
+        descendants.forEach((descendant) => this.addToGraph(subscriberPackageVersion, descendant));
+        return descendants;
+    }
+    addToGraph(ancestor, descendant) {
+        if (!this.graph.hasNode(ancestor.getVersion())) {
+            this.graph.addNode(ancestor.getVersion(), { node: ancestor });
+        }
+        if (!this.graph.hasNode(descendant.getVersion())) {
+            this.graph.addNode(descendant.getVersion(), { node: descendant });
+        }
+        if (!this.graph.hasEdge(ancestor.getVersion(), descendant.getVersion())) {
+            this.graph.addDirectedEdgeWithKey(`${ancestor.getVersion()}->${descendant.getVersion()}`, ancestor.getVersion(), descendant.getVersion(), {
+                from: ancestor.getVersion(),
+                to: descendant.getVersion(),
+            });
+        }
+    }
+    async getDescendants(ancestor) {
+        const query = `${SELECT_PACKAGE_VERSION} WHERE AncestorId = '${ancestor.SubscriberPackageVersionId}' ${releasedOnlyFilter}`;
+        const results = await this.options.connection.tooling.query(query);
+        return results.records.map((result) => new PackageAncestryNode(result));
+    }
+}
+exports.PackageAncestry = PackageAncestry;
+class AncestryTreeProducer extends tree_1.Tree {
+    constructor(options) {
+        super();
+        this.verbose = false;
+        this.options = options;
+        this.label = this.options?.node?.getVersion() || 'root';
+        this.verbose = this.options?.verbose || false;
+    }
+    addNode(node) {
+        const label = this.createLabel(node);
+        this.insert(label, node);
+    }
+    produce() {
+        const producers = [];
+        producers.push(this);
+        while (producers.length > 0) {
+            const producer = producers.shift();
+            Object.values(producer.nodes)
+                .sort((a, b) => a.options.node.version.compareTo(b.options.node.version))
+                .forEach((child) => {
+                delete producer.nodes[this.createLabel(child)];
+                producer.addNode(child);
+                producers.push(child);
+            });
+        }
+        this.display(this.options ? this.options['logger'] : undefined);
+    }
+    createLabel(node) {
+        const subscriberId = this.verbose && node?.options?.node?.SubscriberPackageVersionId
+            ? ` (${node.options.node.SubscriberPackageVersionId})`
+            : '';
+        return node?.label ? `${node.label}${subscriberId}` : 'root';
+    }
+}
+exports.AncestryTreeProducer = AncestryTreeProducer;
+class AncestryJsonProducer {
+    constructor(options) {
+        this.children = [];
+        this.options = options;
+        this.label = this.options?.node?.getVersion() || 'root';
+        this.data = {
+            children: [],
+            data: {
+                SubscriberPackageVersionId: this.options?.node?.SubscriberPackageVersionId,
+                MajorVersion: this.options?.node?.MajorVersion,
+                MinorVersion: this.options?.node?.MinorVersion,
+                PatchVersion: this.options?.node?.PatchVersion,
+                BuildNumber: this.options?.node?.BuildNumber,
+                depthCounter: this.options?.depth,
+            },
+        };
+    }
+    addNode(node) {
+        this.data.children.push(node.data);
+        this.children.push(node);
+    }
+    produce() {
+        const producers = [];
+        producers.push(this);
+        while (producers.length > 0) {
+            const producer = producers.shift();
+            producer.data.children.sort((a, b) => {
+                const aVersion = new versionNumber_1.VersionNumber(a.data.MajorVersion, a.data.MinorVersion, a.data.PatchVersion, a.data.BuildNumber);
+                const bVersion = new versionNumber_1.VersionNumber(b.data.MajorVersion, b.data.MinorVersion, b.data.PatchVersion, b.data.BuildNumber);
+                return aVersion.compareTo(bVersion);
+            });
+            producers.push(...producer.children);
+        }
+        return this.data.children[0];
+    }
+}
+exports.AncestryJsonProducer = AncestryJsonProducer;
+class AncestryDotProducer {
+    constructor(options) {
+        this.children = [];
+        this.options = options;
+        this.label = this.options?.node?.getVersion() || 'root';
+    }
+    /**
+     * Builds a node line in DOT, of the form nodeID [label="MAJOR.MINOR.PATCH"]
+     *
+     * @param currentNode
+     */
+    static buildDotNode(currentNode) {
+        return `\t node${currentNode.options.node.SubscriberPackageVersionId} [label="${currentNode.label}"]`;
+    }
+    /**
+     * Builds an edge line in DOT, of the form fromNode -- toNode
+     *
+     * @param fromNode
+     * @param toNode
+     */
+    static buildDotEdge(fromNode, toNode) {
+        return `\t node${fromNode.options.node.SubscriberPackageVersionId} -- node${toNode.options.node.SubscriberPackageVersionId}`;
+    }
+    addNode(node) {
+        this.children.push(node);
+    }
+    produce() {
+        const producers = [];
+        producers.push(this);
+        const dotLines = [];
+        while (producers.length > 0) {
+            const producer = producers.shift();
+            if (producer.options) {
+                dotLines.push(AncestryDotProducer.buildDotNode(producer));
+            }
+            producers.push(...producer.children);
+        }
+        producers.push(this);
+        while (producers.length > 0) {
+            const producer = producers.shift();
+            if (producer.options) {
+                producer.children.forEach((child) => dotLines.push(AncestryDotProducer.buildDotEdge(producer, child)));
+            }
+            producers.push(...producer.children);
+        }
+        return `strict graph G {${os_1.EOL}${dotLines.join(os_1.EOL)}${os_1.EOL}}`;
+    }
+}
+exports.AncestryDotProducer = AncestryDotProducer;
+class PackageAncestryNode extends kit_1.AsyncCreatable {
+    constructor(options) {
+        super(options);
+        this.options = options;
+        _PackageAncestryNode_version.set(this, void 0);
+        _PackageAncestryNode_MajorVersion.set(this, void 0);
+        _PackageAncestryNode_MinorVersion.set(this, void 0);
+        _PackageAncestryNode_PatchVersion.set(this, void 0);
+        _PackageAncestryNode_BuildNumber.set(this, void 0);
+        _PackageAncestryNode_AncestorId.set(this, void 0);
+        _PackageAncestryNode_SubscriberPackageVersionId.set(this, void 0);
+        _PackageAncestryNode_depthCounter.set(this, void 0);
+        __classPrivateFieldSet(this, _PackageAncestryNode_version, new versionNumber_1.VersionNumber(this.options.MajorVersion, this.options.MinorVersion, this.options.PatchVersion, this.options.BuildNumber), "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_AncestorId, this.options.AncestorId, "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_SubscriberPackageVersionId, this.options.SubscriberPackageVersionId, "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_MajorVersion, typeof this.options.MajorVersion === 'number'
+            ? this.options.MajorVersion
+            : parseInt(this.options.MajorVersion, 10), "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_MinorVersion, typeof this.options.MinorVersion === 'number'
+            ? this.options.MinorVersion
+            : parseInt(this.options.MinorVersion, 10), "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_PatchVersion, typeof this.options.PatchVersion === 'number'
+            ? this.options.PatchVersion
+            : parseInt(this.options.PatchVersion, 10), "f");
+        __classPrivateFieldSet(this, _PackageAncestryNode_BuildNumber, this.options.BuildNumber, "f");
+    }
+    get AncestorId() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_AncestorId, "f");
+    }
+    get SubscriberPackageVersionId() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_SubscriberPackageVersionId, "f");
+    }
+    get version() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_version, "f");
+    }
+    get MinorVersion() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_MinorVersion, "f");
+    }
+    get PatchVersion() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_PatchVersion, "f");
+    }
+    get BuildNumber() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_BuildNumber, "f");
+    }
+    get MajorVersion() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_MajorVersion, "f");
+    }
+    get depthCounter() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_depthCounter, "f");
+    }
+    getVersion() {
+        return __classPrivateFieldGet(this, _PackageAncestryNode_version, "f").toString();
+    }
+    init() {
+        return Promise.resolve();
+    }
+}
+exports.PackageAncestryNode = PackageAncestryNode;
+_PackageAncestryNode_version = new WeakMap(), _PackageAncestryNode_MajorVersion = new WeakMap(), _PackageAncestryNode_MinorVersion = new WeakMap(), _PackageAncestryNode_PatchVersion = new WeakMap(), _PackageAncestryNode_BuildNumber = new WeakMap(), _PackageAncestryNode_AncestorId = new WeakMap(), _PackageAncestryNode_SubscriberPackageVersionId = new WeakMap(), _PackageAncestryNode_depthCounter = new WeakMap();
+//# sourceMappingURL=packageAncestry.js.map

package/lib/package/packageInstall.js

@@ -105,8 +105,7 @@ async function getExternalSites(connection, subscriberPackageVersionId, installa
 }
 exports.getExternalSites = getExternalSites;
 async function getStatus(connection, installRequestId) {
-    const result = await connection.tooling.retrieve('PackageInstallRequest', installRequestId);
-    return result;
+    return (await connection.tooling.retrieve('PackageInstallRequest', installRequestId));
 }
 exports.getStatus = getStatus;
 // internal

package/lib/package/packageVersionCreate.js

@@ -167,7 +167,7 @@ class PackageVersionCreate {
     async resolveBuildNumber(versionNumber, packageId, branch) {
         if (!versionNumber.isbuildKeyword()) {
             // The build number is already specified so just return it using the tooling query result obj structure
-            return versionNumber.build;
+            return `${versionNumber.build}`;
         }
         // query for the LATEST or RELEASED build number (excluding deleted versions)
         let branchCondition = '';

package/lib/package/packageVersionList.js

@@ -13,7 +13,7 @@ const utils_1 = require("../utils");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
 // Stripping CodeCoverage, HasPassedCodeCoverageCheck as they are causing a perf issue in 47.0+ W-6997762
-const DEFAULT_SELECT = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name, Package2.Name, Package2.NamespacePrefix, ' +
+const DEFAULT_SELECT = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name, Package2.Name, Package2.NamespacePrefix, Package2.IsOrgDependent, ' +
     'Description, Tag, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber, IsReleased, ' +
     'CreatedDate, LastModifiedDate, IsPasswordProtected, AncestorId, ValidationSkipped, CreatedById ' +
     'FROM Package2Version';

package/lib/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './packageUtils';
 export * from './srcDevUtils';
+export * from './versionNumber';

package/lib/utils/index.js

@@ -22,4 +22,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./packageUtils"), exports);
 __exportStar(require("./srcDevUtils"), exports);
+__exportStar(require("./versionNumber"), exports);
 //# sourceMappingURL=index.js.map

package/lib/utils/packageUtils.js

@@ -74,7 +74,7 @@ exports.validateIdNoThrow = validateIdNoThrow;
 function validateVersionNumber(versionNumberString, supportedBuildNumberToken, supportedBuildNumberToken2) {
     const versionNumber = versionNumber_1.VersionNumber.from(versionNumberString);
     // build number can be a number or valid token
-    if (Number.isNaN(parseInt(versionNumber.build, 10)) &&
+    if (Number.isNaN(parseInt(`${versionNumber.build}`, 10)) &&
         versionNumber.build !== supportedBuildNumberToken &&
         versionNumber.build !== supportedBuildNumberToken2) {
         if (supportedBuildNumberToken2) {

package/lib/utils/versionNumber.d.ts

@@ -6,12 +6,13 @@ export declare enum BuildNumberToken {
     NONE_VERSION_NUMBER_TOKEN = "NONE"
 }
 export declare class VersionNumber {
-    major: string;
-    minor: string;
-    patch: string;
-    build: string;
-    private constructor();
+    major: string | number;
+    minor: string | number;
+    patch: string | number;
+    build: string | number;
+    constructor(major: string | number, minor: string | number, patch: string | number, build: string | number);
     static from(versionString: string): VersionNumber;
     toString(): string;
     isbuildKeyword(): boolean;
+    compareTo(other: VersionNumber): number;
 }

package/lib/utils/versionNumber.js

@@ -54,7 +54,33 @@ class VersionNumber {
     isbuildKeyword() {
         return Object.values(BuildNumberToken)
             .map((v) => v.toString())
-            .includes(this.build.toLowerCase());
+            .includes(typeof this.build === 'string' && this.build.toUpperCase());
+    }
+    compareTo(other) {
+        const [aMajor, aMinor, aPatch, aBuild] = [this.major, this.minor, this.patch, this.build].map((v) => typeof v === 'number' ? v : parseInt(v, 10));
+        const [oMajor, oMinor, oPatch, oBuild] = [other.major, other.minor, other.patch, other.build].map((v) => typeof v === 'number' ? v : parseInt(v, 10));
+        if (aMajor !== oMajor) {
+            return aMajor - oMajor;
+        }
+        if (aMinor !== oMinor) {
+            return aMinor - oMinor;
+        }
+        if (aPatch !== oPatch) {
+            return aPatch - oPatch;
+        }
+        if (isNaN(aBuild) && isNaN(oBuild)) {
+            return 0;
+        }
+        if (isNaN(aBuild)) {
+            return 1;
+        }
+        if (isNaN(oBuild)) {
+            return -1;
+        }
+        if (aBuild !== oBuild) {
+            return aBuild - oBuild;
+        }
+        return 0;
     }
 }
 exports.VersionNumber = VersionNumber;

package/messages/messages.md

@@ -177,6 +177,14 @@ Only one package in a Dev Hub is allowed per converted from first-generation pac
 
 Multiple errors occurred:
 
+# errorScriptsNotApplicableToUnlockedPackage
+
+We can’t create the package version. This parameter is available only for second-generation managed packages. Create the package version without the postinstallscript or uninstallscript parameters.,
+
+# errorAncestorNotApplicableToUnlockedPackage
+
+Can’t create package version. Specifying an ancestor is available only for second-generation managed packages. Remove the ancestorId or ancestorVersion from your sfdx-project.json file, and then create the package version again.,
+
 # itemDoesNotFitWithinMaxLength
 
 When calculating the number of items to be included in query "%s", when formatted, was too long.
@@ -203,10 +211,34 @@ The %s value, [%s], and %s value, [%s], were both found in sfdx-project.json but
 
 The provided package ID '%s' is invalid.
 
+# tempFileLocation
+
+The temp files are located at: %s.
+
+# failedToCreatePVCRequest
+
+Failed to create request %s: %s
+
+# versionNumberNotFoundInDevHub
+
+No version number was found in Dev Hub for package id %s and branch %s and version number %s that resolved to build number %s.
+
+# noReleaseVersionFound
+
+No released version was found in Dev Hub for package id %s and version number %s.
+
+# noReleaseVersionFoundForBranch
+
+No version number was found in Dev Hub for package id $s and branch %s and version number %s.
+
 # packagingDirNotFoundInConfigFile
 
 Config file %s does not contain a packaging directory for %s.
 
+# unpackagedMDDirectoryDoesNotExist
+
+Un-packaged metadata directory %s was specified but does not exist.
+
 # directoryDoesNotExist
 
 Directory %s does not exist.
@@ -231,3 +263,7 @@ Verify installed package ID and resolve errors, then try again.
 # errorNoSubscriberPackageRecord
 
 No subscriber package was found for seed id: %s'
+
+# idOrAliasNotFound
+
+Can't find package with id or alias: %s

package/messages/package.md

@@ -5,3 +5,11 @@ The %s: [%s] is invalid. It must start with "%s".
 # invalidIdLength
 
 The %s: [%s] is invalid. It must be either 15 or 18 characters.
+
+# defaultErrorMessage
+
+Can't uninstall the package %s during uninstall request %s.
+
+# action
+
+Verify installed package ID and resolve errors, then try again.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/packaging",
-  "version": "0.0.29",
+  "version": "0.0.32",
   "description": "packing libraries to Salesforce packaging platform",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -35,6 +35,7 @@
     "!lib/**/*.map"
   ],
   "dependencies": {
+    "@oclif/core": "^1.14.2",
     "@salesforce/core": "^3.26.2",
     "@salesforce/kit": "^1.6.0",
     "@salesforce/schemas": "^1.2.0",
@@ -43,6 +44,9 @@
     "@xmldom/xmldom": "^0.8.2",
     "debug": "^4.3.4",
     "globby": "^11",
+    "graphology": "^0.24.1",
+    "graphology-traversal": "^0.3.1",
+    "graphology-types": "^0.24.4",
     "js2xmlparser": "^4.0.2",
     "jsforce": "beta",
     "jszip": "^3.10.0",