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

package/src/publish/publish-alpha.ts

@@ -0,0 +1,144 @@
+import * as fs from "node:fs";
+import { PACKAGE_CONFIGURATION_PATH, PACKAGE_LOCK_CONFIGURATION_PATH, Publish } from "./publish.js";
+import { logger } from "./logger.js";
+
+const BACKUP_PACKAGE_CONFIGURATION_PATH = ".package.json";
+
+/**
+ * Publish alpha versions.
+ */
+class PublishAlpha extends Publish {
+    /**
+     * If true, update all dependencies automatically.
+     */
+    private readonly _updateAll: boolean;
+
+    /**
+     * Constructor.
+     *
+     * If true, outputs what would be run rather than running it.
+     *
+     * @param updateAll
+     * If true, update all dependencies automatically.
+     *
+     * @param dryRun
+     * If true, outputs what would be run rather than running it.
+     */
+    constructor(updateAll: boolean, dryRun: boolean) {
+        super("alpha", dryRun);
+
+        this._updateAll = updateAll;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected publish(): void {
+        let anyDependencyUpdates = false;
+
+        // Check for external dependency updates, even if there are no changes.
+        for (const currentDependencies of [this.packageConfiguration.devDependencies, this.packageConfiguration.dependencies]) {
+            if (currentDependencies !== undefined) {
+                for (const [dependency, 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 (latestVersion !== version.substring(1)) {
+                            logger.info(`Dependency ${dependency}@${version} ${!this._updateAll ? "pending update" : "updating"} to version ${latestVersion}.`);
+
+                            if (this._updateAll) {
+                                currentDependencies[dependency] = `^${latestVersion}`;
+
+                                anyDependencyUpdates = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (anyDependencyUpdates) {
+            // Save the dependency updates; this will be detected by call to anyChanges().
+            this.savePackageConfiguration();
+        }
+
+        if (this._updateAll) {
+            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);
+        }
+
+        const anyChanges = this.anyChanges(this.repository.lastAlphaPublished, true);
+
+        if (anyChanges) {
+            const switchToAlpha = this.preReleaseIdentifier !== "alpha";
+
+            if (switchToAlpha) {
+                // Previous publication was beta or production.
+                this.updatePackageVersion(undefined, undefined, this.patchVersion + 1, "alpha");
+
+                // Use specified registry for organization until no longer in alpha mode.
+                this.run(false, false, "npm", "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);
+            }
+        }
+
+        // Run lint if present.
+        this.run(false, false, "npm", "run", "lint", "--if-present");
+
+        // Run development build if present.
+        this.run(false, false, "npm", "run", "build:dev", "--if-present");
+
+        if (anyChanges) {
+            const nowISOString = new Date().toISOString();
+
+            // Nothing further required if this repository is not a dependency of others.
+            if (this.repository.dependencyType !== "none") {
+                if (!this.dryRun) {
+                    // Backup the package configuration file.
+                    fs.renameSync(PACKAGE_CONFIGURATION_PATH, BACKUP_PACKAGE_CONFIGURATION_PATH);
+                }
+
+                try {
+                    // Package version is transient.
+                    this.updatePackageVersion(undefined, undefined, undefined, `alpha.${nowISOString.replaceAll(/\D/g, "").substring(0, 12)}`);
+
+                    // Publish to development NPM registry.
+                    this.run(false, false, "npm", "publish", "--tag", "alpha");
+
+                    // 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}`);
+                        }
+                    }
+                } finally {
+                    if (!this.dryRun) {
+                        // Restore the package configuration file.
+                        fs.rmSync(PACKAGE_CONFIGURATION_PATH);
+                        fs.renameSync(BACKUP_PACKAGE_CONFIGURATION_PATH, PACKAGE_CONFIGURATION_PATH);
+                    }
+                }
+            }
+
+            this.commitUpdatedPackageVersion(PACKAGE_CONFIGURATION_PATH, PACKAGE_LOCK_CONFIGURATION_PATH);
+
+            this.repository.lastAlphaPublished = nowISOString;
+        }
+    }
+}
+
+// Detailed syntax checking not required as this is an internal tool.
+await new PublishAlpha(process.argv.includes("--update-all"), process.argv.includes("--dry-run")).publishAll().catch((e: unknown) => {
+    logger.error(e);
+});

package/src/publish/publish-beta.ts

@@ -0,0 +1,293 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { setTimeout } from "node:timers/promises";
+import { Octokit } from "octokit";
+import { parse as yamlParse } from "yaml";
+import secureConfigurationJSON from "../../config/publish.secure.json";
+import { Publish } from "./publish.js";
+import { logger } from "./logger.js";
+
+/**
+ * Configuration layout of publish.secure.json.
+ */
+interface SecureConfiguration {
+    token: string;
+}
+
+/**
+ * Configuration layout of release.yml workflow (relevant attributes only).
+ */
+interface WorkflowConfiguration {
+    /**
+     * Workflow name.
+     */
+    name: string;
+
+    /**
+     * Workflow trigger.
+     */
+    on: {
+        /**
+         * Push trigger.
+         */
+        push?: {
+            /**
+             * Push branches.
+             */
+            branches?: string[];
+        };
+
+        /**
+         * Release trigger.
+         */
+        release?: {
+            /**
+             * Release types.
+             */
+            types?: string[];
+        };
+    };
+}
+
+/**
+ * Publish steps.
+ */
+type Step = "install" | "build" | "commit" | "tag" | "push" | "workflow (push)" | "release" | "workflow (release)";
+
+/**
+ * Publish beta versions.
+ */
+class PublishBeta extends Publish {
+    /**
+     * Secure configuration.
+     */
+    private readonly _secureConfiguration: SecureConfiguration = secureConfigurationJSON;
+
+    /**
+     * Octokit.
+     */
+    private readonly _octokit: Octokit;
+
+    /**
+     * Constructor.
+     *
+     * @param dryRun
+     * If true, outputs what would be run rather than running it.
+     */
+    constructor(dryRun: boolean) {
+        super("beta", dryRun);
+
+        this._octokit = new Octokit({
+            auth: this._secureConfiguration.token,
+            userAgent: `${this.configuration.organization} release`
+        });
+    }
+
+    /**
+     * Run a step.
+     *
+     * Repository.
+     *
+     * @param step
+     * State at which step takes place.
+     *
+     * @param stepRunner
+     * Callback to execute step.
+     */
+    private async runStep(step: Step, stepRunner: () => (void | Promise<void>)): Promise<void> {
+        if (this.repository.publishBetaStep === undefined || this.repository.publishBetaStep === step) {
+            logger.debug(`Running step ${step}`);
+
+            this.repository.publishBetaStep = step;
+
+            await stepRunner();
+
+            this.repository.publishBetaStep = undefined;
+        } else {
+            logger.debug(`Skipping step ${step}`);
+        }
+    }
+
+    /**
+     * Validate the workflow by waiting for it to complete.
+     *
+     * Branch on which workflow is running.
+     */
+    private async validateWorkflow(): Promise<void> {
+        if (this.dryRun) {
+            logger.info("Dry run: Validate workflow");
+        } else {
+            const commitSHA = this.run(true, true, "git", "rev-parse", this.branch)[0];
+
+            let completed = false;
+            let queryCount = 0;
+            let workflowRunID = -1;
+
+            do {
+                // eslint-disable-next-line no-await-in-loop -- Loop depends on awaited response.
+                const response = await setTimeout(2000).then(
+                    async () => this._octokit.rest.actions.listWorkflowRunsForRepo({
+                        owner: this.configuration.organization,
+                        repo: this.repositoryName,
+                        head_sha: commitSHA
+                    })
+                );
+
+                for (const workflowRun of response.data.workflow_runs) {
+                    if (workflowRun.status !== "completed") {
+                        if (workflowRun.id === workflowRunID) {
+                            process.stdout.write(".");
+                        } else if (workflowRunID === -1) {
+                            workflowRunID = workflowRun.id;
+
+                            logger.info(`Workflow run ID ${workflowRunID}`);
+                        } else {
+                            throw new Error(`Parallel workflow runs for SHA ${commitSHA}`);
+                        }
+                    } else if (workflowRun.id === workflowRunID) {
+                        process.stdout.write("\n");
+
+                        if (workflowRun.conclusion !== "success") {
+                            throw new Error(`Workflow ${workflowRun.conclusion}`);
+                        }
+
+                        completed = true;
+                    }
+                }
+
+                // Abort if workflow run not started after 10 queries.
+                if (++queryCount === 10 && workflowRunID === -1) {
+                    throw new Error(`Workflow run not started for SHA ${commitSHA}`);
+                }
+            } while (!completed);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected async publish(): Promise<void> {
+        let publish: boolean;
+
+        // Scrap any incomplete publishing if pre-release identifier is not beta.
+        if (this.preReleaseIdentifier !== "beta") {
+            this.repository.publishBetaStep = undefined;
+        }
+
+        if (this.preReleaseIdentifier === "alpha") {
+            if (this.anyChanges(this.repository.lastAlphaPublished, true)) {
+                throw new Error("Repository has changed since last alpha published");
+            }
+
+            publish = true;
+
+            this.updatePackageVersion(undefined, undefined, undefined, "beta");
+        } else {
+            // Publish beta step is defined if previous attempt failed at that step.
+            publish = this.repository.publishBetaStep !== undefined;
+
+            // 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 (publish) {
+            const tag = `v${this.packageConfiguration.version}`;
+
+            if (this.repository.publishBetaStep !== undefined) {
+                logger.debug(`Repository failed at step "${this.repository.publishBetaStep}" on prior run`);
+            }
+
+            const workflowsPath = ".github/workflows/";
+
+            let hasPushWorkflow = false;
+            let hasReleaseWorkflow = false;
+
+            if (fs.existsSync(workflowsPath)) {
+                logger.debug("Checking workflows");
+
+                for (const workflowFile of fs.readdirSync(workflowsPath).filter(workflowFile => workflowFile.endsWith(".yml"))) {
+                    // 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*"))) {
+                        logger.debug("Repository has push workflow");
+
+                        hasPushWorkflow = true;
+                    }
+
+                    if (workflowOn.release !== undefined && (workflowOn.release.types === undefined || workflowOn.release.types.includes("published"))) {
+                        logger.debug("Repository has release workflow");
+
+                        hasReleaseWorkflow = true;
+                    }
+                }
+            }
+
+            await this.runStep("install", () => {
+                this.run(false, false, "npm", "install", ...this.npmPlatformArgs);
+            });
+
+            await this.runStep("build", () => {
+                this.run(false, false, "npm", "run", "build:release", "--if-present");
+            });
+
+            await this.runStep("commit", () => {
+                this.commitUpdatedPackageVersion();
+            });
+
+            await this.runStep("tag", () => {
+                this.run(false, false, "git", "tag", tag);
+            });
+
+            await this.runStep("push", () => {
+                this.run(false, false, "git", "push", "--atomic", "origin", this.branch, tag);
+            });
+
+            if (hasPushWorkflow) {
+                await this.runStep("workflow (push)", async () => {
+                    await this.validateWorkflow();
+                });
+            }
+
+            await this.runStep("release", async () => {
+                if (this.dryRun) {
+                    logger.info("Dry run: Create release");
+                } else {
+                    await this._octokit.rest.repos.createRelease({
+                        owner: this.configuration.organization,
+                        repo: this.repositoryName,
+                        tag_name: tag,
+                        name: `Release ${tag}`,
+                        prerelease: true
+                    });
+                }
+            });
+
+            if (hasReleaseWorkflow) {
+                await this.runStep("workflow (release)", async () => {
+                    await this.validateWorkflow();
+                });
+            }
+
+            this.repository.lastBetaPublished = new Date().toISOString();
+            this.repository.publishBetaStep = undefined;
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    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;
+        }
+    }
+}
+
+// Detailed syntax checking not required as this is an internal tool.
+await new PublishBeta(process.argv.includes("--dry-run")).publishAll().catch((e: unknown) => {
+    logger.error(e);
+});