@aidc-toolkit/dev 0.9.19-beta → 0.9.21-beta

package/src/publish/publish-alpha.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import type { Repository } from "./configuration";
 import { PACKAGE_CONFIGURATION_PATH, PACKAGE_LOCK_CONFIGURATION_PATH, Publish } from "./publish.js";
 import { logger } from "./logger.js";
 
@@ -30,27 +31,54 @@ class PublishAlpha extends Publish {
         this._updateAll = updateAll;
     }
 
+    /**
+     * @inheritDoc
+     */
+    protected dependencyVersionFor(): string {
+        // Dependency version is always "alpha".
+        return "alpha";
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected getPhaseDateTime(repository: Repository, phaseDateTime: Date): Date {
+        // If beta or production has been published since the last alpha, use that instead.
+        return this.latestDateTime(phaseDateTime, repository.phaseStates.beta?.dateTime, repository.phaseStates.production?.dateTime);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected isValidBranch(): boolean {
+        // Any branch is valid for alpha publication.
+        return true;
+    }
+
     /**
      * @inheritDoc
      */
     protected publish(): void {
-        let anyDependencyUpdates = false;
+        let anyExternalUpdates = false;
+
+        const repositoryState = this.repositoryState;
+        const packageConfiguration = repositoryState.packageConfiguration;
 
-        // Check for external dependency updates, even if there are no changes.
-        for (const currentDependencies of [this.packageConfiguration.devDependencies, this.packageConfiguration.dependencies]) {
+        // Check for external updates, even if there are no changes.
+        for (const currentDependencies of [packageConfiguration.devDependencies, packageConfiguration.dependencies]) {
             if (currentDependencies !== undefined) {
-                for (const [dependency, version] of Object.entries(currentDependencies)) {
+                for (const [dependencyPackageName, version] of Object.entries(currentDependencies)) {
                     // Ignore organization dependencies.
-                    if (this.dependencyRepositoryName(dependency) === null && version.startsWith("^")) {
-                        const [latestVersion] = this.run(true, true, "npm", "view", dependency, "version");
+                    if (this.dependencyRepositoryName(dependencyPackageName) === null && version.startsWith("^")) {
+                        const [latestVersion] = this.run(true, true, "npm", "view", dependencyPackageName, "version");
 
                         if (latestVersion !== version.substring(1)) {
-                            logger.info(`Dependency ${dependency}@${version} ${!this._updateAll ? "pending update" : "updating"} to version ${latestVersion}.`);
+                            logger.info(`Dependency ${dependencyPackageName}@${version} ${!this._updateAll ? "pending update" : "updating"} to version ${latestVersion}.`);
 
                             if (this._updateAll) {
-                                currentDependencies[dependency] = `^${latestVersion}`;
+                                currentDependencies[dependencyPackageName] = `^${latestVersion}`;
 
-                                anyDependencyUpdates = true;
+                                anyExternalUpdates = true;
                             }
                         }
                     }
@@ -58,7 +86,7 @@ class PublishAlpha extends Publish {
             }
         }
 
-        if (anyDependencyUpdates) {
+        if (anyExternalUpdates) {
             // Save the dependency updates; this will be detected by call to anyChanges().
             this.savePackageConfiguration();
         }
@@ -67,28 +95,24 @@ class PublishAlpha extends Publish {
             logger.debug("Updating all dependencies");
 
             // Running this even if there are no dependency updates will update dependencies of dependencies.
-            this.run(false, false, "npm", "update", ...this.npmPlatformArgs);
+            this.run(false, false, "npm", "update", ...repositoryState.npmPlatformArgs);
         }
 
-        const anyChanges = this.anyChanges(this.repository.lastAlphaPublished, true);
+        const anyChanges = this.anyChanges(repositoryState.phaseDateTime, true) || repositoryState.anyDependenciesUpdated;
 
         if (anyChanges) {
-            const switchToAlpha = this.preReleaseIdentifier !== "alpha";
+            const switchToAlpha = repositoryState.preReleaseIdentifier !== "alpha";
 
             if (switchToAlpha) {
                 // Previous publication was beta or production.
-                this.updatePackageVersion(undefined, undefined, this.patchVersion + 1, "alpha");
+                this.updatePackageVersion(undefined, undefined, repositoryState.patchVersion + 1, "alpha");
 
                 // Use specified registry for organization until no longer in alpha mode.
-                this.run(false, false, "npm", "set", this.atOrganizationRegistry, "--location", "project");
+                this.run(false, false, "npm", "config", "set", this.atOrganizationRegistry, "--location", "project");
             }
 
-            if (this.organizationDependenciesUpdated && (switchToAlpha || !this._updateAll)) {
-                const updateOrganizationDependencies = Object.values(this.organizationDependencies).filter(updateOrganizationDependency => updateOrganizationDependency !== null);
-
-                logger.debug(`Updating organization dependencies [${updateOrganizationDependencies.join(", ")}]`);
-
-                this.run(false, false, "npm", "update", ...updateOrganizationDependencies, ...this.npmPlatformArgs);
+            if (repositoryState.anyDependenciesUpdated && (switchToAlpha || !this._updateAll)) {
+                this.updateOrganizationDependencies();
             }
         }
 
@@ -99,10 +123,11 @@ class PublishAlpha extends Publish {
         this.run(false, false, "npm", "run", "build:dev", "--if-present");
 
         if (anyChanges) {
-            const nowISOString = new Date().toISOString();
+            const now = new Date();
+            const nowISOString = now.toISOString();
 
             // Nothing further required if this repository is not a dependency of others.
-            if (this.repository.dependencyType !== "none") {
+            if (repositoryState.repository.dependencyType !== "none") {
                 if (!this.dryRun) {
                     // Backup the package configuration file.
                     fs.renameSync(PACKAGE_CONFIGURATION_PATH, BACKUP_PACKAGE_CONFIGURATION_PATH);
@@ -117,9 +142,9 @@ class PublishAlpha extends Publish {
 
                     // Unpublish all prior alpha versions.
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Output is a JSON array.
-                    for (const version of JSON.parse(this.run(true, true, "npm", "view", this.packageConfiguration.name, "versions", "--json").join("\n")) as string[]) {
-                        if (/^\d+.\d+.\d+-alpha.\d+$/.test(version) && version !== this.packageConfiguration.version) {
-                            this.run(false, false, "npm", "unpublish", `${this.packageConfiguration.name}@${version}`);
+                    for (const version of JSON.parse(this.run(true, true, "npm", "view", packageConfiguration.name, "versions", "--json").join("\n")) as string[]) {
+                        if (/^\d+.\d+.\d+-alpha.\d+$/.test(version) && version !== packageConfiguration.version) {
+                            this.run(false, false, "npm", "unpublish", `${packageConfiguration.name}@${version}`);
                         }
                     }
                 } finally {
@@ -133,7 +158,9 @@ class PublishAlpha extends Publish {
 
             this.commitUpdatedPackageVersion(PACKAGE_CONFIGURATION_PATH, PACKAGE_LOCK_CONFIGURATION_PATH);
 
-            this.repository.lastAlphaPublished = nowISOString;
+            this.updatePhaseState({
+                dateTime: now
+            });
         }
     }
 }

package/src/publish/publish-beta.ts

@@ -4,6 +4,7 @@ import { setTimeout } from "node:timers/promises";
 import { Octokit } from "octokit";
 import { parse as yamlParse } from "yaml";
 import secureConfigurationJSON from "../../config/publish.secure.json";
+import type { Repository } from "./configuration";
 import { Publish } from "./publish.js";
 import { logger } from "./logger.js";
 
@@ -35,7 +36,7 @@ interface WorkflowConfiguration {
              * Push branches.
              */
             branches?: string[];
-        };
+        } | null;
 
         /**
          * Release trigger.
@@ -45,14 +46,14 @@ interface WorkflowConfiguration {
              * Release types.
              */
             types?: string[];
-        };
+        } | null;
     };
 }
 
 /**
  * Publish steps.
  */
-type Step = "install" | "build" | "commit" | "tag" | "push" | "workflow (push)" | "release" | "workflow (release)";
+type Step = "update" | "build" | "commit" | "tag" | "push" | "workflow (push)" | "release" | "workflow (release)" | "complete";
 
 /**
  * Publish beta versions.
@@ -83,6 +84,52 @@ class PublishBeta extends Publish {
         });
     }
 
+    /**
+     * @inheritDoc
+     */
+    protected dependencyVersionFor(dependencyRepositoryName: string, dependencyRepository: Repository): string {
+        let dependencyVersion: string;
+
+        switch (dependencyRepository.dependencyType) {
+            case "external":
+                dependencyVersion = "beta";
+                break;
+
+            case "internal": {
+                const betaTag = dependencyRepository.phaseStates.beta?.tag;
+
+                if (betaTag === undefined) {
+                    throw new Error(`*** Internal error *** Beta tag not set for ${dependencyRepositoryName}`);
+                }
+
+                dependencyVersion = `${this.configuration.organization}/${dependencyRepositoryName}#${betaTag}`;
+            }
+                break;
+
+            default:
+                throw new Error(`Invalid dependency type "${dependencyRepository.dependencyType}" for dependency ${dependencyRepositoryName}`);
+        }
+
+        return dependencyVersion;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected getPhaseDateTime(repository: Repository, phaseDateTime: Date): Date {
+        return this.latestDateTime(phaseDateTime, repository.phaseStates.production?.dateTime);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected isValidBranch(): boolean {
+        const repositoryState = this.repositoryState;
+
+        // Branch for beta phase must match version.
+        return repositoryState.branch === `v${repositoryState.majorVersion}.${repositoryState.minorVersion}`;
+    }
+
     /**
      * Run a step.
      *
@@ -95,14 +142,20 @@ class PublishBeta extends Publish {
      * Callback to execute step.
      */
     private async runStep(step: Step, stepRunner: () => (void | Promise<void>)): Promise<void> {
-        if (this.repository.publishBetaStep === undefined || this.repository.publishBetaStep === step) {
+        const phaseStateStep = this.repositoryState.phaseState.step;
+
+        if (phaseStateStep === undefined || phaseStateStep === step) {
             logger.debug(`Running step ${step}`);
 
-            this.repository.publishBetaStep = step;
+            this.updatePhaseState({
+                step
+            });
 
             await stepRunner();
 
-            this.repository.publishBetaStep = undefined;
+            this.updatePhaseState({
+                step: undefined
+            });
         } else {
             logger.debug(`Skipping step ${step}`);
         }
@@ -117,7 +170,7 @@ class PublishBeta extends Publish {
         if (this.dryRun) {
             logger.info("Dry run: Validate workflow");
         } else {
-            const commitSHA = this.run(true, true, "git", "rev-parse", this.branch)[0];
+            const commitSHA = this.run(true, true, "git", "rev-parse", this.repositoryState.branch)[0];
 
             let completed = false;
             let queryCount = 0;
@@ -128,7 +181,7 @@ class PublishBeta extends Publish {
                 const response = await setTimeout(2000).then(
                     async () => this._octokit.rest.actions.listWorkflowRunsForRepo({
                         owner: this.configuration.organization,
-                        repo: this.repositoryName,
+                        repo: this.repositoryState.repositoryName,
                         head_sha: commitSHA
                     })
                 );
@@ -169,34 +222,42 @@ class PublishBeta extends Publish {
     protected async publish(): Promise<void> {
         let publish: boolean;
 
+        const repositoryState = this.repositoryState;
+
         // Scrap any incomplete publishing if pre-release identifier is not beta.
-        if (this.preReleaseIdentifier !== "beta") {
-            this.repository.publishBetaStep = undefined;
+        if (repositoryState.preReleaseIdentifier !== "beta") {
+            repositoryState.phaseState.step = undefined;
         }
 
-        if (this.preReleaseIdentifier === "alpha") {
-            if (this.anyChanges(this.repository.lastAlphaPublished, true)) {
+        if (repositoryState.preReleaseIdentifier === "alpha") {
+            if (this.anyChanges(repositoryState.repository.phaseStates.alpha?.dateTime, false)) {
                 throw new Error("Repository has changed since last alpha published");
             }
 
             publish = true;
 
             this.updatePackageVersion(undefined, undefined, undefined, "beta");
+
+            // Revert to default registry for organization.
+            this.run(false, false, "npm", "config", "delete", this.atOrganizationRegistry, "--location", "project");
         } else {
-            // Publish beta step is defined if previous attempt failed at that step.
-            publish = this.repository.publishBetaStep !== undefined;
+            const step = repositoryState.phaseState.step;
+            const startingPublication = step === undefined;
+
+            // Step is defined and not "complete" if previous attempt failed at that step.
+            publish = !startingPublication && step !== "complete";
 
             // Ignore changes after publication process has started.
-            if (!publish && this.anyChanges(this.repository.lastBetaPublished, false)) {
-                throw new Error("Internal error, repository has changed without intermediate alpha publication");
+            if (startingPublication && this.anyChanges(repositoryState.repository.phaseStates.alpha?.dateTime, false)) {
+                throw new Error("Repository has changed since last alpha published");
             }
         }
 
         if (publish) {
-            const tag = `v${this.packageConfiguration.version}`;
+            const tag = `v${repositoryState.packageConfiguration.version}`;
 
-            if (this.repository.publishBetaStep !== undefined) {
-                logger.debug(`Repository failed at step "${this.repository.publishBetaStep}" on prior run`);
+            if (repositoryState.phaseState.step !== undefined) {
+                logger.debug(`Repository failed at step "${repositoryState.phaseState.step}" on prior run`);
             }
 
             const workflowsPath = ".github/workflows/";
@@ -211,13 +272,13 @@ class PublishBeta extends Publish {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Workflow configuration format is known.
                     const workflowOn = (yamlParse(fs.readFileSync(path.resolve(workflowsPath, workflowFile)).toString()) as WorkflowConfiguration).on;
 
-                    if (workflowOn.push !== undefined && (workflowOn.push.branches === undefined || workflowOn.push.branches.includes("v*"))) {
+                    if (workflowOn.push !== undefined && (workflowOn.push?.branches === undefined || workflowOn.push.branches.includes("v*"))) {
                         logger.debug("Repository has push workflow");
 
                         hasPushWorkflow = true;
                     }
 
-                    if (workflowOn.release !== undefined && (workflowOn.release.types === undefined || workflowOn.release.types.includes("published"))) {
+                    if (workflowOn.release !== undefined && (workflowOn.release?.types === undefined || workflowOn.release.types.includes("published"))) {
                         logger.debug("Repository has release workflow");
 
                         hasReleaseWorkflow = true;
@@ -225,12 +286,15 @@ class PublishBeta extends Publish {
                 }
             }
 
-            await this.runStep("install", () => {
-                this.run(false, false, "npm", "install", ...this.npmPlatformArgs);
+            await this.runStep("update", () => {
+                this.updateOrganizationDependencies();
             });
 
             await this.runStep("build", () => {
                 this.run(false, false, "npm", "run", "build:release", "--if-present");
+
+                // Run test if present; must be part of build as correcting errors will require rebuild.
+                this.run(false, false, "npm", "run", "test", "--if-present");
             });
 
             await this.runStep("commit", () => {
@@ -242,7 +306,7 @@ class PublishBeta extends Publish {
             });
 
             await this.runStep("push", () => {
-                this.run(false, false, "git", "push", "--atomic", "origin", this.branch, tag);
+                this.run(false, false, "git", "push", "--atomic", "origin", repositoryState.branch, tag);
             });
 
             if (hasPushWorkflow) {
@@ -257,7 +321,7 @@ class PublishBeta extends Publish {
                 } else {
                     await this._octokit.rest.repos.createRelease({
                         owner: this.configuration.organization,
-                        repo: this.repositoryName,
+                        repo: repositoryState.repositoryName,
                         tag_name: tag,
                         name: `Release ${tag}`,
                         prerelease: true
@@ -271,8 +335,11 @@ class PublishBeta extends Publish {
                 });
             }
 
-            this.repository.lastBetaPublished = new Date().toISOString();
-            this.repository.publishBetaStep = undefined;
+            this.updatePhaseState({
+                dateTime: new Date(),
+                tag,
+                step: "complete"
+            });
         }
     }
 
@@ -282,7 +349,8 @@ class PublishBeta extends Publish {
     protected override finalizeAll(): void {
         // Publication complete; reset steps to undefined for next run.
         for (const repository of Object.values(this.configuration.repositories)) {
-            repository.publishBetaStep = undefined;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- All beta phase states are defined by this point.
+            repository.phaseStates.beta!.step = undefined;
         }
     }
 }