@ebay-dt/bonfire-node 0.1.0 → 0.2.0-alpha.10

package/dist/lifecycle/local-prototype-lifecycle.js

@@ -2,8 +2,8 @@ import { constants } from "node:fs";
 import { lstat, open, rename, rm, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join, relative, sep } from "node:path";
-import { definePrototypeRef, getPrototypeUrl, LifecycleInputError, lifecycleFailure, lifecycleSuccess, parseCreatePrototypeInput, parseDuplicatePrototypeInput, parseEditPrototypeInput, parseBonfireIdentity, parsePrototypeCommandInput, parsePrototypeMetadata, slugifyPrototypeTitle, PrototypeRefError, } from "@ebay-dt/bonfire-core";
-import { commitPath, discardPath, GitRepositoryError, prepareIdentityBranch, pushBranch, } from "../git-repository.js";
+import { definePrototypeRef, getPrototypeUrl, LifecycleInputError, lifecycleFailure, lifecycleSuccess, parseCreatePrototypeInput, parseDuplicatePrototypeInput, parseEditPrototypeInput, parseBonfireIdentity, parsePrototypeCommandInput, parsePrototypeMetadata, slugifyPrototypeTitle, PrototypeRefError, parseGitModeSetting, } from "@ebay-dt/bonfire-core";
+import { commitPath, discardPath, GitRepositoryError, pushBranch, pushCommitToBranch, } from "../git-repository.js";
 import { duplicatePrototype, PrototypeDuplicateError } from "../duplicate.js";
 import { PrototypeCatalog, } from "../prototype-catalog.js";
 import { PrototypeScaffoldError, scaffoldPrototype } from "../scaffold.js";
@@ -11,6 +11,9 @@ import { createPrototypeLifecycleRuntime, } from "./runtime-context.js";
 import { cleanupOwnedDestination, validateOwnedDestination, } from "../internal/owned-destination.js";
 import { RepositoryBusyError, withRepositoryOperation, } from "./operation-gate.js";
 import { DeploymentProviderError, } from "../deployment-provider.js";
+import { assertIdentityBranchReady, synchronizeIdentityBranch, } from "./repository-synchronization.js";
+import { getRepositorySummary } from "./repository-summary.js";
+import { DeploymentWorktreeError, preflightDeploymentSource, publishDeploymentSource, reportDeploymentIssue, } from "./deployment-worktree.js";
 function repositoryRelativePath(runtime, ref) {
     const absolutePath = join(runtime.prototypeRoot, ref.login, ref.slug);
     return relative(runtime.repositoryRoot, absolutePath).split(sep).join("/");
@@ -29,6 +32,10 @@ class PrototypeMetadataFileError extends Error {
 }
 class DeploymentUnavailableError extends Error {
 }
+class DeploymentSourcePushError extends Error {
+}
+class DeploymentNotAcceptedError extends Error {
+}
 function metadataPath(runtime, ref) {
     return join(runtime.prototypeRoot, ref.login, ref.slug, "metadata.json");
 }
@@ -112,26 +119,6 @@ async function writeMetadataDocument(runtime, ref, document) {
         await rm(temporaryPath, { force: true }).catch(() => undefined);
     }
 }
-async function mergeIdentityBranchToPrimary(repository, options) {
-    if (options.branch === options.primaryBranch)
-        return;
-    const hasRemote = (await repository.remotes()).some((remote) => remote.name === options.remote);
-    if (!hasRemote)
-        return;
-    await repository.checkout([options.primaryBranch]);
-    try {
-        await repository.merge([
-            options.branch,
-            "--no-ff",
-            "-m",
-            `merge: ${options.branch}`,
-        ]);
-        await repository.push(options.remote, options.primaryBranch);
-    }
-    finally {
-        await repository.checkout([options.branch]);
-    }
-}
 function mapError(error) {
     if (error instanceof PrototypeNotFoundError)
         return "not-found";
@@ -173,6 +160,11 @@ function mapError(error) {
     if (error instanceof DeploymentUnavailableError) {
         return "deployment-unavailable";
     }
+    if (error instanceof DeploymentSourcePushError ||
+        error instanceof DeploymentNotAcceptedError ||
+        error instanceof DeploymentWorktreeError) {
+        return "deployment-failure";
+    }
     if (error instanceof DeploymentProviderError) {
         return error.kind === "timeout" ? "timeout" : "deployment-failure";
     }
@@ -183,19 +175,35 @@ function resultFrom(operation) {
         .then(lifecycleSuccess)
         .catch((error) => lifecycleFailure(mapError(error)));
 }
+async function diagnoseMetadataStep(step, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        reportDeploymentIssue("publication", step, error);
+        throw error;
+    }
+}
 export class LocalPrototypeLifecycle {
     #runtime;
+    gitMode;
     #catalog;
     #repository;
     #preparePrototypeFiles;
     #deploymentProvider;
     #applicationId;
     #themeRegistry;
+    #restartRequired = false;
+    #pendingPublication;
     constructor(options) {
         const internalOptions = options;
-        this.#runtime =
-            internalOptions.runtime ??
-                createPrototypeLifecycleRuntime(internalOptions);
+        const runtime = internalOptions.runtime ??
+            createPrototypeLifecycleRuntime(internalOptions);
+        this.#runtime = {
+            ...runtime,
+            gitMode: parseGitModeSetting(runtime.gitMode),
+        };
+        this.gitMode = this.#runtime.gitMode;
         this.#themeRegistry = options.themeRegistry;
         this.#catalog =
             internalOptions.catalog ??
@@ -241,14 +249,7 @@ export class LocalPrototypeLifecycle {
         };
     }
     async #prepareMutationBranch(login) {
-        if (this.#runtime.automaticBranchSwitch === "disabled") {
-            return this.#currentBranch();
-        }
-        await prepareIdentityBranch(this.#repository, {
-            identityBranch: login,
-            primaryBranch: this.#runtime.primaryBranch,
-            remote: this.#runtime.remote,
-        });
+        await assertIdentityBranchReady(this.#repository, login);
         return login;
     }
     async #prepareDestination(receipt, expectedFiles, request) {
@@ -278,16 +279,35 @@ export class LocalPrototypeLifecycle {
         return resultFrom(async () => {
             const verifiedIdentity = await this.#verifiedIdentity(identity);
             return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
-                if (this.#runtime.automaticBranchSwitch === "disabled") {
+                if (this.#runtime.gitMode === "manual" ||
+                    this.#runtime.automaticBranchSwitch === "disabled") {
                     await this.#currentBranch();
                     return { status: "disabled" };
                 }
-                await prepareIdentityBranch(this.#repository, {
+                const synchronization = await synchronizeIdentityBranch(this.#repository, {
                     identityBranch: verifiedIdentity.login,
                     primaryBranch: this.#runtime.primaryBranch,
                     remote: this.#runtime.remote,
+                    managedPaths: this.#runtime.managedRepositoryPaths,
                 });
-                return { status: "ready" };
+                if (synchronization.status !== "synchronized") {
+                    return {
+                        status: synchronization.status,
+                        reason: synchronization.reason,
+                        ...(synchronization.affectedPaths.length > 0
+                            ? { affectedPaths: synchronization.affectedPaths }
+                            : {}),
+                    };
+                }
+                if (synchronization.affectedPaths.some((path) => this.#runtime.managedRepositoryPaths.includes(path))) {
+                    this.#restartRequired = true;
+                }
+                return {
+                    status: "ready",
+                    ...(synchronization.affectedPaths.length > 0
+                        ? { affectedPaths: synchronization.affectedPaths }
+                        : {}),
+                };
             });
         });
     }
@@ -300,7 +320,9 @@ export class LocalPrototypeLifecycle {
                 if (await this.#catalog.getSummary(ref)) {
                     throw new PrototypeScaffoldError("collision");
                 }
-                const branch = await this.#prepareMutationBranch(verifiedIdentity.login);
+                const branch = this.#runtime.gitMode === "managed"
+                    ? await this.#prepareMutationBranch(verifiedIdentity.login)
+                    : undefined;
                 const prepared = await scaffoldPrototype({
                     paths: this.#runtime,
                     ref,
@@ -320,6 +342,13 @@ export class LocalPrototypeLifecycle {
                     title: normalizedInput.title,
                     description: normalizedInput.description,
                 });
+                if (branch === undefined) {
+                    return {
+                        ref,
+                        url: getPrototypeUrl(ref),
+                        remoteStatus: "manual",
+                    };
+                }
                 await commitPath(this.#repository, repositoryRelativePath(this.#runtime, ref), `init: ${ref.slug}`);
                 const push = await pushBranch(this.#repository, this.#runtime.remote, branch);
                 return {
@@ -338,7 +367,9 @@ export class LocalPrototypeLifecycle {
                 const { ref, path } = await this.#ownedPrototype(verifiedIdentity, {
                     ref: normalizedInput.ref,
                 });
-                const branch = await this.#prepareMutationBranch(verifiedIdentity.login);
+                const branch = this.#runtime.gitMode === "managed"
+                    ? await this.#prepareMutationBranch(verifiedIdentity.login)
+                    : undefined;
                 await assertPrototypeDirectory(this.#runtime, ref);
                 const document = await readMetadataDocument(this.#runtime, ref, this.#themeRegistry);
                 const metadata = parsePrototypeMetadata(document, {
@@ -356,8 +387,10 @@ export class LocalPrototypeLifecycle {
                         ? {}
                         : { theme: normalizedInput.theme }),
                 });
-                await commitPath(this.#repository, path, `edit: ${ref.slug}`);
-                await pushBranch(this.#repository, this.#runtime.remote, branch);
+                if (branch !== undefined) {
+                    await commitPath(this.#repository, path, `edit: ${ref.slug}`);
+                    await pushBranch(this.#repository, this.#runtime.remote, branch);
+                }
                 return { edited: true, ref };
             });
         });
@@ -368,10 +401,14 @@ export class LocalPrototypeLifecycle {
             const normalizedInput = parsePrototypeCommandInput(input);
             return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
                 const { ref, path } = await this.#ownedPrototype(verifiedIdentity, normalizedInput);
-                const branch = await this.#prepareMutationBranch(verifiedIdentity.login);
+                const branch = this.#runtime.gitMode === "managed"
+                    ? await this.#prepareMutationBranch(verifiedIdentity.login)
+                    : undefined;
                 await removePrototypeDirectory(this.#runtime, ref);
-                await commitPath(this.#repository, path, `delete: ${ref.slug}`);
-                await pushBranch(this.#repository, this.#runtime.remote, branch);
+                if (branch !== undefined) {
+                    await commitPath(this.#repository, path, `delete: ${ref.slug}`);
+                    await pushBranch(this.#repository, this.#runtime.remote, branch);
+                }
                 return { deleted: true, ref };
             });
         });
@@ -388,7 +425,113 @@ export class LocalPrototypeLifecycle {
             };
         });
     }
+    async getRepositorySummary(identity) {
+        return resultFrom(async () => {
+            const verifiedIdentity = await this.#verifiedIdentity(identity);
+            return getRepositorySummary({
+                repository: this.#repository,
+                catalog: this.#catalog,
+                repositoryRoot: this.#runtime.repositoryRoot,
+                prototypeRoot: this.#runtime.prototypeRoot,
+                identity: verifiedIdentity,
+                mode: this.#runtime.gitMode,
+                remote: this.#runtime.remote,
+                primaryBranch: this.#runtime.primaryBranch,
+                restartRequired: this.#restartRequired,
+            });
+        });
+    }
+    async checkRepositorySummary(identity) {
+        return resultFrom(async () => {
+            const verifiedIdentity = await this.#verifiedIdentity(identity);
+            return getRepositorySummary({
+                repository: this.#repository,
+                catalog: this.#catalog,
+                repositoryRoot: this.#runtime.repositoryRoot,
+                prototypeRoot: this.#runtime.prototypeRoot,
+                identity: verifiedIdentity,
+                mode: this.#runtime.gitMode,
+                remote: this.#runtime.remote,
+                primaryBranch: this.#runtime.primaryBranch,
+                restartRequired: this.#restartRequired,
+                refresh: true,
+            });
+        });
+    }
+    async #headCommit() {
+        const commit = (await this.#repository.raw(["rev-parse", "HEAD"])).trim();
+        if (!/^[0-9a-f]{40,64}$/iu.test(commit)) {
+            throw new GitRepositoryError("malformed-output", "head-commit");
+        }
+        return commit.toLowerCase();
+    }
+    async #prepareDeploymentBranch(login) {
+        if (this.#runtime.automaticBranchSwitch === "disabled") {
+            await assertIdentityBranchReady(this.#repository, login);
+            return "updates-not-synchronized";
+        }
+        const synchronization = await synchronizeIdentityBranch(this.#repository, {
+            identityBranch: login,
+            primaryBranch: this.#runtime.primaryBranch,
+            remote: this.#runtime.remote,
+            managedPaths: this.#runtime.managedRepositoryPaths,
+        });
+        if (synchronization.status === "unsafe") {
+            throw new GitRepositoryError("conflict", "deployment-preparation");
+        }
+        await assertIdentityBranchReady(this.#repository, login);
+        return synchronization.status === "deferred"
+            ? "updates-not-synchronized"
+            : undefined;
+    }
+    #workspaceRuntime(workspacePath, workspaceRepository) {
+        return {
+            ...this.#runtime,
+            repositoryRoot: workspacePath,
+            repositoryRealPath: workspacePath,
+            prototypeRoot: join(workspacePath, relative(this.#runtime.repositoryRoot, this.#runtime.prototypeRoot)),
+            gitRepository: workspaceRepository,
+        };
+    }
+    async #publishDeploymentMetadata(pending) {
+        return publishDeploymentSource(this.#repository, {
+            remote: this.#runtime.remote,
+            primaryBranch: this.#runtime.primaryBranch,
+            sourceSha: pending.sourceSha,
+            commitIdentity: this.#runtime.commitIdentity,
+        }, async ({ path, repository }) => {
+            const workspaceRuntime = this.#workspaceRuntime(path, repository);
+            const mergedDocument = await diagnoseMetadataStep("metadata-read", () => readMetadataDocument(workspaceRuntime, pending.ref, this.#themeRegistry));
+            await diagnoseMetadataStep("metadata-write", () => writeMetadataDocument(workspaceRuntime, pending.ref, {
+                ...mergedDocument,
+                previewUrl: pending.previewUrl,
+                updatedAt: new Date().toISOString(),
+            }));
+            await diagnoseMetadataStep("metadata-commit", () => commitPath(repository, pending.path, `deploy: ${pending.ref.slug} (metadata)`));
+        });
+    }
+    async #deploymentValue(pending, publicationWarnings = []) {
+        const warnings = [
+            ...(pending.synchronizationWarning === undefined
+                ? []
+                : [pending.synchronizationWarning]),
+            ...publicationWarnings,
+        ];
+        return {
+            deployed: true,
+            ref: pending.ref,
+            previewUrl: pending.previewUrl,
+            deploymentId: pending.deploymentId,
+            sourceSha: pending.sourceSha,
+            readyState: pending.readyState,
+            warning: publicationWarnings[0] ?? pending.synchronizationWarning,
+            ...(warnings.length === 0 ? {} : { warnings }),
+        };
+    }
     async deploy(identity, input) {
+        if (this.#runtime.gitMode === "manual") {
+            return lifecycleFailure("forbidden");
+        }
         return resultFrom(async () => {
             const verifiedIdentity = await this.#verifiedIdentity(identity);
             const normalizedInput = parsePrototypeCommandInput(input);
@@ -397,7 +540,7 @@ export class LocalPrototypeLifecycle {
             }
             return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
                 const { ref, path } = await this.#ownedPrototype(verifiedIdentity, normalizedInput);
-                const branch = await this.#prepareMutationBranch(verifiedIdentity.login);
+                const synchronizationWarning = await this.#prepareDeploymentBranch(verifiedIdentity.login);
                 await assertPrototypeDirectory(this.#runtime, ref);
                 const document = await readMetadataDocument(this.#runtime, ref, this.#themeRegistry);
                 const metadata = parsePrototypeMetadata(document, {
@@ -407,60 +550,104 @@ export class LocalPrototypeLifecycle {
                     throw new PrototypeNotFoundError();
                 }
                 await commitPath(this.#repository, path, `deploy: ${ref.slug}`);
-                await pushBranch(this.#repository, this.#runtime.remote, branch);
+                const sourceSha = await this.#headCommit();
+                const sourcePush = await pushCommitToBranch(this.#repository, this.#runtime.remote, sourceSha, verifiedIdentity.login);
+                if (sourcePush.remoteStatus !== "pushed") {
+                    throw new DeploymentSourcePushError();
+                }
+                await preflightDeploymentSource(this.#repository, {
+                    remote: this.#runtime.remote,
+                    primaryBranch: this.#runtime.primaryBranch,
+                    sourceSha,
+                    commitIdentity: this.#runtime.commitIdentity,
+                });
                 const deployment = await this.#deploymentProvider.deploy({
                     applicationId: this.#applicationId,
                     login: verifiedIdentity.login,
                 });
-                const previewUrl = new URL(getPrototypeUrl(ref).slice(1), `${deployment.url.replace(/\/+$/, "")}/`).toString();
-                let warning;
-                try {
-                    await writeMetadataDocument(this.#runtime, ref, {
-                        ...document,
-                        previewUrl,
-                        updatedAt: new Date().toISOString(),
-                    });
-                    await commitPath(this.#repository, path, `deploy: ${ref.slug} (metadata)`);
-                    await pushBranch(this.#repository, this.#runtime.remote, branch);
-                }
-                catch {
-                    warning = "metadata-persistence-failed";
+                if (deployment.commitSha.toLowerCase() !== sourceSha ||
+                    !["READY", "QUEUED", "INITIALIZING", "BUILDING"].includes(deployment.readyState)) {
+                    throw new DeploymentNotAcceptedError();
                 }
-                if (warning === undefined) {
-                    try {
-                        await mergeIdentityBranchToPrimary(this.#repository, {
-                            branch,
-                            primaryBranch: this.#runtime.primaryBranch,
-                            remote: this.#runtime.remote,
-                        });
-                    }
-                    catch {
-                        warning = "primary-merge-failed";
-                    }
-                }
-                return {
-                    deployed: true,
+                const previewUrl = new URL(getPrototypeUrl(ref).slice(1), `${deployment.url.replace(/\/+$/, "")}/`).toString();
+                const pending = {
+                    identity: verifiedIdentity,
+                    input: normalizedInput,
                     ref,
+                    path,
                     previewUrl,
                     deploymentId: deployment.deploymentId,
+                    sourceSha,
                     readyState: deployment.readyState,
-                    warning,
+                    synchronizationWarning,
                 };
+                try {
+                    const publication = await this.#publishDeploymentMetadata(pending);
+                    this.#pendingPublication = undefined;
+                    return this.#deploymentValue(pending, publication.cleanupFailed ? ["publication-cleanup-failed"] : []);
+                }
+                catch (error) {
+                    // Keep the accepted deployment retryable for every publication
+                    // failure, including metadata preparation failures.
+                    this.#pendingPublication = pending;
+                    return this.#deploymentValue(pending, [
+                        error instanceof DeploymentWorktreeError &&
+                            error.kind !== "cleanup-failure"
+                            ? "primary-merge-failed"
+                            : "metadata-persistence-failed",
+                        ...(error instanceof DeploymentWorktreeError &&
+                            error.cleanupFailed
+                            ? ["publication-cleanup-failed"]
+                            : []),
+                    ]);
+                }
+            });
+        });
+    }
+    async retryPublish(identity, input) {
+        if (this.#runtime.gitMode === "manual") {
+            return lifecycleFailure("forbidden");
+        }
+        return resultFrom(async () => {
+            const verifiedIdentity = await this.#verifiedIdentity(identity);
+            const normalizedInput = parsePrototypeCommandInput(input);
+            const pending = this.#pendingPublication;
+            if (pending === undefined ||
+                pending.identity.login !== verifiedIdentity.login ||
+                pending.ref.login !== normalizedInput.ref.login ||
+                pending.ref.slug !== normalizedInput.ref.slug) {
+                throw new DeploymentUnavailableError();
+            }
+            return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
+                await assertIdentityBranchReady(this.#repository, verifiedIdentity.login);
+                const publication = await this.#publishDeploymentMetadata(pending);
+                this.#pendingPublication = undefined;
+                return this.#deploymentValue(pending, publication.cleanupFailed ? ["publication-cleanup-failed"] : []);
             });
         });
     }
     async save(identity, input) {
+        if (this.#runtime.gitMode === "manual") {
+            return lifecycleFailure("forbidden");
+        }
         return resultFrom(async () => {
-            const { ref, path } = await this.#ownedPrototype(identity, input);
+            const verifiedIdentity = await this.#verifiedIdentity(identity);
+            const { ref, path } = await this.#ownedPrototype(verifiedIdentity, input);
             return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
+                await this.#prepareMutationBranch(verifiedIdentity.login);
                 await commitPath(this.#repository, path, `save: ${ref.slug}`);
+                await pushBranch(this.#repository, this.#runtime.remote, verifiedIdentity.login);
                 return { saved: true };
             });
         });
     }
     async discard(identity, input) {
+        if (this.#runtime.gitMode === "manual") {
+            return lifecycleFailure("forbidden");
+        }
         return resultFrom(async () => {
-            const { path } = await this.#ownedPrototype(identity, input);
+            const verifiedIdentity = await this.#verifiedIdentity(identity);
+            const { path } = await this.#ownedPrototype(verifiedIdentity, input);
             return withRepositoryOperation(this.#runtime.repositoryRealPath, async () => {
                 await discardPath(this.#repository, path);
                 return { discarded: true };
@@ -479,7 +666,9 @@ export class LocalPrototypeLifecycle {
                 if (await this.#catalog.getSummary(ref)) {
                     throw new PrototypeDuplicateError("collision");
                 }
-                const branch = await this.#prepareMutationBranch(verifiedIdentity.login);
+                const branch = this.#runtime.gitMode === "managed"
+                    ? await this.#prepareMutationBranch(verifiedIdentity.login)
+                    : undefined;
                 const prepared = await duplicatePrototype({
                     paths: this.#runtime,
                     source: normalizedInput.source,
@@ -500,6 +689,13 @@ export class LocalPrototypeLifecycle {
                     title: normalizedInput.title,
                     description: normalizedInput.description,
                 });
+                if (branch === undefined) {
+                    return {
+                        ref,
+                        url: getPrototypeUrl(ref),
+                        remoteStatus: "manual",
+                    };
+                }
                 await commitPath(this.#repository, repositoryRelativePath(this.#runtime, ref), `init: ${ref.slug}`);
                 const push = await pushBranch(this.#repository, this.#runtime.remote, branch);
                 return {