@clickview/ship-it 0.0.53 → 0.0.54-dev.0

package/lib/src/tasks/InstallPackagesTask.js

@@ -59,6 +59,7 @@ var semver_1 = __importDefault(require("semver"));
 var child_process_1 = __importDefault(require("child_process"));
 var types_1 = require("../types");
 var services_1 = require("../services");
+var errors_1 = require("../errors");
 var utils_1 = require("../utils");
 var MonorepoPackageJsonFiles_1 = require("../constants/MonorepoPackageJsonFiles");
 var ROOT_DIRECTORIES = {
@@ -79,22 +80,29 @@ var ROOT_DIRECTORIES = {
     // Streamable learning
     1144: 'src/StreamableLearning.Web'
 };
+/**
+ * npm accepts a publish before the version can be resolved from the registry. Large packages get
+ * queued for background processing ("Your package is being processed and may take a few minutes to
+ * become available"), so we poll for up to 5 minutes.
+ */
+var PUBLISH_POLL_ATTEMPTS = 20;
+var PUBLISH_POLL_INTERVAL_MS = 15000;
 var InstallPackagesTask = /** @class */ (function () {
     function InstallPackagesTask(service) {
         this.service = service;
     }
     InstallPackagesTask.prototype.run = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var targetBranch, projectId, project, versions_1, folderName, hasUpdates, error_1, milestone, projects, monorepo, consumingProjects, _a, monorepoBranch, monorepoBranchName, versions, _i, consumingProjects_1, project, _b, branch, branchName, hasUpdates, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var targetBranch, projectId, project, versions_1, folderName, updatedPackages, error_1, milestone, projects, monorepo, consumingProjects, _a, monorepoBranch, monorepoBranchName, versions, failedProjects, _i, consumingProjects_1, project, _b, branch, branchName, updatedPackages, error_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         utils_1.Logger.logTask('Installing npm packages');
                         if (!options.monorepoBranchName && !options.milestone) {
                             utils_1.Logger.logError('Please provide either a milestone or branch name argument.');
                             return [2 /*return*/, false];
                         }
-                        if (!(options.targetBranchName && options.monorepoBranchName && options.projectIds)) return [3 /*break*/, 8];
+                        if (!(options.targetBranchName && options.monorepoBranchName && options.projectIds)) return [3 /*break*/, 9];
                         targetBranch = options.targetBranchName;
                         if (targetBranch.startsWith('release') && !options.monorepoBranchName.startsWith('release')) {
                             utils_1.Logger.logError('Attempting to target release with non release branch.');
@@ -111,28 +119,39 @@ var InstallPackagesTask = /** @class */ (function () {
                         projectId = options.projectIds[0];
                         return [4 /*yield*/, this.service.getProject(projectId)];
                     case 1:
-                        project = _d.sent();
+                        project = _c.sent();
                         return [4 /*yield*/, this.getPackageVersions(options.monorepoBranchName)];
                     case 2:
-                        versions_1 = _d.sent();
+                        versions_1 = _c.sent();
                         folderName = 'hotfix';
                         utils_1.Logger.logMessage("Versions identified for ".concat(options.monorepoBranchName));
                         Object.keys(versions_1).forEach(function (key) {
                             utils_1.Logger.logMessage("- [".concat(key, "]: ").concat(versions_1[key]));
                         });
-                        _d.label = 3;
+                        _c.label = 3;
                     case 3:
-                        _d.trys.push([3, 6, , 7]);
+                        _c.trys.push([3, 7, , 8]);
                         return [4 /*yield*/, this.updateAndSavePackageFiles(project, folderName, targetBranch, versions_1)];
                     case 4:
-                        hasUpdates = _d.sent();
+                        updatedPackages = _c.sent();
                         /**
                          * If there are no changes to the versions, we're done here
                          */
-                        if (!hasUpdates) {
+                        if (!updatedPackages.length) {
                             utils_1.Logger.logWarning("[".concat(project.title, "]: [").concat(targetBranch, "] does not require any updates"));
                             return [2 /*return*/, true];
                         }
+                        /**
+                         * The versions come from git, so they can be ahead of the registry. Wait for them to become
+                         * installable before npm tries to resolve them
+                         */
+                        return [4 /*yield*/, this.waitForPublishedVersions(project, updatedPackages)];
+                    case 5:
+                        /**
+                         * The versions come from git, so they can be ahead of the registry. Wait for them to become
+                         * installable before npm tries to resolve them
+                         */
+                        _c.sent();
                         /**
                          * Run npm i to update our package log file
                         */
@@ -143,33 +162,34 @@ var InstallPackagesTask = /** @class */ (function () {
                          * Commit our updated package.json and package-lock.json
                          */
                         return [4 /*yield*/, this.commitUpdatedFiles(project, folderName, targetBranch)];
-                    case 5:
+                    case 6:
                         /**
                          * Commit our updated package.json and package-lock.json
                          */
-                        _d.sent();
+                        _c.sent();
                         utils_1.Logger.logMessage("[".concat(project.title, "]: File changes committed"));
-                        return [3 /*break*/, 7];
-                    case 6:
-                        error_1 = _d.sent();
+                        return [3 /*break*/, 8];
+                    case 7:
+                        error_1 = _c.sent();
                         utils_1.Logger.logError("[".concat(project.title, "]: Something went wrong while attempting to install packages. Please manually check if this project should have any monorepo packages installed."));
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/, true];
-                    case 8:
+                        utils_1.Logger.logError(this.getErrorMessage(error_1));
+                        return [2 /*return*/, false];
+                    case 8: return [2 /*return*/, true];
+                    case 9:
                         milestone = options.milestone;
-                        if (!!milestone) return [3 /*break*/, 10];
+                        if (!!milestone) return [3 /*break*/, 11];
                         utils_1.Logger.logInfo("Searching for a merge request in project \"monorepo\" with branch name \"".concat(options.monorepoBranchName, "\"..."));
                         return [4 /*yield*/, this.service.getMilestoneByBranchName(utils_1.ProjectIds.MONOREPO_PROJECT_ID, options.monorepoBranchName)];
-                    case 9:
-                        milestone = _d.sent();
-                        _d.label = 10;
                     case 10:
+                        milestone = _c.sent();
+                        _c.label = 11;
+                    case 11:
                         if (!milestone)
                             return [2 /*return*/, false];
                         utils_1.Logger.logInfo("Found milestone \"".concat(milestone, "\". Proceeding to install packages in consuming projects..."));
                         return [4 /*yield*/, this.service.getReleaseProjects(milestone, options.projectIds, options.omittedProjectIds, options.sourceBranch)];
-                    case 11:
-                        projects = _d.sent();
+                    case 12:
+                        projects = _c.sent();
                         monorepo = projects.find(function (p) { return p.id.toString() === utils_1.ProjectIds.MONOREPO_PROJECT_ID; });
                         consumingProjects = projects.filter(function (p) { return p.id.toString() !== utils_1.ProjectIds.MONOREPO_PROJECT_ID; });
                         if (!monorepo) {
@@ -181,45 +201,57 @@ var InstallPackagesTask = /** @class */ (function () {
                             return [2 /*return*/, false];
                         }
                         return [4 /*yield*/, this.service.getNextBranchInfo(monorepo.id, options.version)];
-                    case 12:
-                        _a = _d.sent(), monorepoBranch = _a.branch, monorepoBranchName = _a.branchName;
+                    case 13:
+                        _a = _c.sent(), monorepoBranch = _a.branch, monorepoBranchName = _a.branchName;
                         if (!monorepoBranch) {
                             utils_1.Logger.logError("[".concat(monorepo.title, "]: [").concat(monorepoBranchName, "] branch does not exist"));
                             return [2 /*return*/, false];
                         }
                         return [4 /*yield*/, this.getPackageVersions(monorepoBranchName)];
-                    case 13:
-                        versions = _d.sent();
+                    case 14:
+                        versions = _c.sent();
                         utils_1.Logger.logMessage("Versions identified for ".concat(monorepoBranchName));
                         Object.keys(versions).forEach(function (key) {
                             utils_1.Logger.logMessage("- [".concat(key, "]: ").concat(versions[key]));
                         });
                         utils_1.Logger.logMessage('\nInstalling packages:\n');
+                        failedProjects = [];
                         _i = 0, consumingProjects_1 = consumingProjects;
-                        _d.label = 14;
-                    case 14:
-                        if (!(_i < consumingProjects_1.length)) return [3 /*break*/, 21];
-                        project = consumingProjects_1[_i];
-                        _d.label = 15;
+                        _c.label = 15;
                     case 15:
-                        _d.trys.push([15, 19, , 20]);
-                        return [4 /*yield*/, this.service.getNextBranchInfo(project.id, options.version)];
+                        if (!(_i < consumingProjects_1.length)) return [3 /*break*/, 23];
+                        project = consumingProjects_1[_i];
+                        _c.label = 16;
                     case 16:
-                        _b = _d.sent(), branch = _b.branch, branchName = _b.branchName;
+                        _c.trys.push([16, 21, , 22]);
+                        return [4 /*yield*/, this.service.getNextBranchInfo(project.id, options.version)];
+                    case 17:
+                        _b = _c.sent(), branch = _b.branch, branchName = _b.branchName;
                         if (!branch) {
                             utils_1.Logger.logError("[".concat(project.title, "]: [").concat(branchName, "] does not exist"));
-                            return [3 /*break*/, 20];
+                            return [3 /*break*/, 22];
                         }
                         return [4 /*yield*/, this.updateAndSavePackageFiles(project, milestone, branchName, versions)];
-                    case 17:
-                        hasUpdates = _d.sent();
+                    case 18:
+                        updatedPackages = _c.sent();
                         /**
                          * If there are no changes to the versions, we're done here
                          */
-                        if (!hasUpdates) {
+                        if (!updatedPackages.length) {
                             utils_1.Logger.logWarning("[".concat(project.title, "]: [").concat(branchName, "] does not require any updates"));
-                            return [3 /*break*/, 20];
+                            return [3 /*break*/, 22];
                         }
+                        /**
+                         * The versions come from git, so they can be ahead of the registry. Wait for them to become
+                         * installable before npm tries to resolve them
+                         */
+                        return [4 /*yield*/, this.waitForPublishedVersions(project, updatedPackages)];
+                    case 19:
+                        /**
+                         * The versions come from git, so they can be ahead of the registry. Wait for them to become
+                         * installable before npm tries to resolve them
+                         */
+                        _c.sent();
                         /**
                          * Run npm i to update our package log file
                          */
@@ -230,25 +262,40 @@ var InstallPackagesTask = /** @class */ (function () {
                          * Commit our updated package.json and package-lock.json
                          */
                         return [4 /*yield*/, this.commitUpdatedFiles(project, milestone, branchName)];
-                    case 18:
+                    case 20:
                         /**
                          * Commit our updated package.json and package-lock.json
                          */
-                        _d.sent();
+                        _c.sent();
                         utils_1.Logger.logMessage("[".concat(project.title, "]: File changes committed"));
-                        return [3 /*break*/, 20];
-                    case 19:
-                        _c = _d.sent();
+                        return [3 /*break*/, 22];
+                    case 21:
+                        error_2 = _c.sent();
                         utils_1.Logger.logError("[".concat(project.title, "]: Something went wrong while attempting to install packages. Please manually check if this project should have any monorepo packages installed."));
-                        return [3 /*break*/, 20];
-                    case 20:
+                        utils_1.Logger.logError(this.getErrorMessage(error_2));
+                        failedProjects.push(project.title);
+                        return [3 /*break*/, 22];
+                    case 22:
                         _i++;
-                        return [3 /*break*/, 14];
-                    case 21: return [2 /*return*/, true];
+                        return [3 /*break*/, 15];
+                    case 23:
+                        /**
+                         * One project failing shouldn't stop the others, but the command still needs to fail so the
+                         * pipeline goes red rather than leaving a project silently behind
+                         */
+                        if (failedProjects.length) {
+                            utils_1.Logger.logError("\nFailed to install packages in ".concat(failedProjects.length, " of ") +
+                                "".concat(consumingProjects.length, " projects: ").concat(failedProjects.join(', ')));
+                            return [2 /*return*/, false];
+                        }
+                        return [2 /*return*/, true];
                 }
             });
         });
     };
+    InstallPackagesTask.prototype.getErrorMessage = function (error) {
+        return error instanceof Error ? error.message : String(error);
+    };
     InstallPackagesTask.prototype.commitUpdatedFiles = function (project, folderName, branchName) {
         return __awaiter(this, void 0, void 0, function () {
             var rootDir, outputPath, commitFiles, _a;
@@ -280,6 +327,81 @@ var InstallPackagesTask = /** @class */ (function () {
             });
         });
     };
+    /**
+     * We read versions out of the monorepo package.json files in git, so a version can be bumped and
+     * published while npm is still processing it in the background. Installing during that window
+     * fails with ETARGET, so wait for each version to become resolvable first.
+     */
+    InstallPackagesTask.prototype.waitForPublishedVersions = function (project, packages) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, packages_1, pkg;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _i = 0, packages_1 = packages;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < packages_1.length)) return [3 /*break*/, 4];
+                        pkg = packages_1[_i];
+                        return [4 /*yield*/, this.waitForPublishedVersion(project, pkg)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    InstallPackagesTask.prototype.waitForPublishedVersion = function (project, pkg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var attempt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attempt = 1;
+                        _a.label = 1;
+                    case 1:
+                        if (!(attempt <= PUBLISH_POLL_ATTEMPTS)) return [3 /*break*/, 4];
+                        if (this.isVersionPublished(pkg)) {
+                            utils_1.Logger.logInfo("[".concat(project.title, "]: ").concat(pkg, " is available on npm"));
+                            return [2 /*return*/];
+                        }
+                        if (!(attempt < PUBLISH_POLL_ATTEMPTS)) return [3 /*break*/, 3];
+                        utils_1.Logger.logWarning("[".concat(project.title, "]: ").concat(pkg, " is not available on npm yet, waiting ") +
+                            "".concat(PUBLISH_POLL_INTERVAL_MS / 1000, "s (attempt ").concat(attempt, "/").concat(PUBLISH_POLL_ATTEMPTS, ")"));
+                        return [4 /*yield*/, this.delay(PUBLISH_POLL_INTERVAL_MS)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        attempt++;
+                        return [3 /*break*/, 1];
+                    case 4: throw new errors_1.ShipItError("[".concat(project.title, "]: ").concat(pkg, " did not become available on npm after ") +
+                        "".concat((PUBLISH_POLL_ATTEMPTS * PUBLISH_POLL_INTERVAL_MS) / 1000, "s. Check that it published successfully."));
+                }
+            });
+        });
+    };
+    InstallPackagesTask.prototype.isVersionPublished = function (pkg) {
+        try {
+            /**
+             * --prefer-online revalidates the cached metadata. The CI npm cache is restored between jobs,
+             * so without it npm can serve back a copy from before the version was published
+             */
+            var output = child_process_1.default.execSync("npm view ".concat(pkg, " version --prefer-online"), { stdio: 'pipe' });
+            return output.toString().trim() !== '';
+        }
+        catch (_a) {
+            // npm exits non-zero when the version does not exist yet
+            return false;
+        }
+    };
+    InstallPackagesTask.prototype.delay = function (ms) {
+        return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+    };
     InstallPackagesTask.prototype.npmInstall = function (project, folderName) {
         var outputPath = this.getOutputPath(project, folderName);
         child_process_1.default.execSync('npm i --package-lock-only --verbose', {
@@ -288,15 +410,18 @@ var InstallPackagesTask = /** @class */ (function () {
             // stdio: 'pipe'
         });
     };
+    /**
+     * Returns the packages whose versions changed, as "name@version" strings
+     */
     InstallPackagesTask.prototype.updateAndSavePackageFiles = function (project, folderName, branchName, versions) {
         return __awaiter(this, void 0, void 0, function () {
-            var rootDir, packageJson, packageLock, packageJsonObj, original, outputPath;
+            var rootDir, packageJson, packageLock, packageJsonObj, updatedPackages, outputPath;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         rootDir = ROOT_DIRECTORIES[project.id];
                         if (!rootDir)
-                            return [2 /*return*/, false];
+                            return [2 /*return*/, []];
                         return [4 /*yield*/, this.getFileText(project.id, branchName, "".concat(rootDir, "/package.json"))];
                     case 1:
                         packageJson = _a.sent();
@@ -304,16 +429,16 @@ var InstallPackagesTask = /** @class */ (function () {
                     case 2:
                         packageLock = _a.sent();
                         packageJsonObj = JSON.parse(packageJson);
-                        original = packageJson;
+                        updatedPackages = [];
                         utils_1.Logger.logMessage(project.title);
                         /**
                          * Annoyingly some projects have clickview packages sitting in dependencies
                          * and others have it in devDependencies
                          */
                         if (packageJsonObj.dependencies)
-                            packageJson = this.replaceVersions(packageJson, versions, packageJsonObj.dependencies);
+                            packageJson = this.replaceVersions(packageJson, versions, packageJsonObj.dependencies, updatedPackages);
                         if (packageJsonObj.devDependencies)
-                            packageJson = this.replaceVersions(packageJson, versions, packageJsonObj.devDependencies);
+                            packageJson = this.replaceVersions(packageJson, versions, packageJsonObj.devDependencies, updatedPackages);
                         outputPath = this.getOutputPath(project, folderName);
                         return [4 /*yield*/, fs_extra_1.default.outputFile("".concat(outputPath, "/package.json"), packageJson, { encoding: 'utf8' })];
                     case 3:
@@ -321,12 +446,12 @@ var InstallPackagesTask = /** @class */ (function () {
                         return [4 /*yield*/, fs_extra_1.default.outputFile("".concat(outputPath, "/package-lock.json"), packageLock, { encoding: 'utf8' })];
                     case 4:
                         _a.sent();
-                        return [2 /*return*/, original !== packageJson];
+                        return [2 /*return*/, updatedPackages];
                 }
             });
         });
     };
-    InstallPackagesTask.prototype.replaceVersions = function (packageJson, versions, deps) {
+    InstallPackagesTask.prototype.replaceVersions = function (packageJson, versions, deps, updatedPackages) {
         Object.keys(deps).forEach(function (key) {
             if (!key.startsWith('@clickview'))
                 return;
@@ -343,6 +468,7 @@ var InstallPackagesTask = /** @class */ (function () {
                 return;
             }
             packageJson = packageJson.replace("\"".concat(key, "\": \"").concat(deps[key], "\""), "\"".concat(key, "\": \"").concat(versions[key], "\""));
+            updatedPackages.push("".concat(key, "@").concat(newVersion));
             utils_1.Logger.logMessage("- [".concat(key, "]: ").concat(deps[key], " -> ").concat(versions[key]));
         });
         return packageJson;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clickview/ship-it",
-  "version": "0.0.53",
+  "version": "0.0.54-dev.0",
   "description": "Release Manager",
   "main": "./lib/index.js",
   "bin": {
@@ -46,4 +46,4 @@
     "tsconfig-paths": "3.14.1",
     "typescript": "5.3.3"
   }
-}
+}