@fjall/deploy-core 0.94.1 → 0.95.0

package/dist/src/services/application/ApplicationStackService.js

@@ -1,218 +1 @@
-import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH } from "../../types/constants.js";
-import { getApplicationStackName } from "../../types/operations.js";
-import { success, failure } from "@fjall/generator";
-import { ApplicationError } from "../../types/application/ApplicationServiceTypes.js";
-import { logger } from "@fjall/util/logger";
-import { convertCloudFormationOutputsToRecord } from "../supporting/helpers.js";
-import { destroyAllStacks, mapSettledResults, resolveWebsiteUrl } from "./applicationStackHelpers.js";
-/**
- * Service for deploying and destroying individual CloudFormation stacks.
- *
- * Handles single-stack deploy/destroy, parallel operations, and the full
- * destroy-all-stacks orchestration.
- *
- * Unlike the CLI version, services are constructor-injected rather than
- * fetched via singleton factories.
- */
-export class ApplicationStackService {
-    cdkService;
-    cloudFormationService;
-    aws;
-    constructor(cdkService, cloudFormationService, aws) {
-        this.cdkService = cdkService;
-        this.cloudFormationService = cloudFormationService;
-        this.aws = aws;
-    }
-    /**
-     * Delegate to CdkService.runCdkSynth — exposed for destroyAllStacks orchestration.
-     */
-    async runCdkSynth(context) {
-        return this.cdkService.runCdkSynth(context);
-    }
-    /**
-     * Deploy a specific stack type for an application
-     */
-    async deployStack(stackType, context, callbacks) {
-        const appName = context.target;
-        const stackName = getApplicationStackName(appName, stackType);
-        const result = await this.cdkService.runCdkDeploy(context, stackName, callbacks?.onOutput, callbacks?.onResourceProgress, this.aws);
-        if (result.success) {
-            const stepData = result.data;
-            logger.debug("ApplicationStackService", "CDK deploy result", {
-                stackName,
-                stackType,
-                success: true,
-                message: stepData.message,
-                status: stepData.status,
-                skipped: stepData.details?.skipped,
-                hasOutput: !!stepData.details?.output
-            });
-            const outputsResult = await this.cloudFormationService.getStackOutputs(stackName);
-            logger.debug("ApplicationStackService", "Stack outputs after deploy", {
-                stackName,
-                hasOutputs: outputsResult.success && outputsResult.data.length > 0,
-                outputCount: outputsResult.success ? outputsResult.data.length : 0
-            });
-            const outputs = outputsResult.success && outputsResult.data.length > 0
-                ? convertCloudFormationOutputsToRecord(outputsResult.data)
-                : undefined;
-            return success({
-                stackType,
-                stackName,
-                skipped: stepData.details?.skipped === true,
-                outputs
-            });
-        }
-        else {
-            const errorMsg = result.error || `Failed to deploy ${stackType} infrastructure`;
-            logger.error("ApplicationStackService", "Stack deployment failed", {
-                stackType,
-                target: context.target,
-                error: errorMsg
-            });
-            return failure(new ApplicationError(errorMsg, {
-                errorType: "deployment_failed",
-                appName: context.target,
-                operation: "deployStack",
-                stackType
-            }));
-        }
-    }
-    /**
-     * Deploy multiple stacks in parallel within a deployment phase.
-     *
-     * Uses Promise.allSettled to ensure all stacks are attempted even if some fail.
-     */
-    async deployStacksInParallel(stacks, context, callbacks) {
-        const onOutputCallback = callbacks?.onOutput;
-        const onResourceProgressCallback = callbacks?.onResourceProgress;
-        const onStackCompleteCallback = callbacks?.onStackComplete;
-        const results = await Promise.allSettled(stacks.map(async (stack) => {
-            const startTime = Date.now();
-            const result = await this.deployStack(stack, context, {
-                onOutput: onOutputCallback
-                    ? (chunk) => onOutputCallback(chunk, stack)
-                    : undefined,
-                onResourceProgress: onResourceProgressCallback
-                    ? (event) => onResourceProgressCallback(event, stack)
-                    : undefined
-            });
-            const duration = Date.now() - startTime;
-            const deploymentResult = {
-                stack,
-                success: result.success,
-                error: result.success ? undefined : result.error,
-                duration,
-                ...(result.success && result.data.outputs !== undefined
-                    ? { outputs: result.data.outputs }
-                    : {})
-            };
-            if (!result.success && result.error) {
-                logger.debug("deployStacksInParallel", `Stack ${stack} failed`, {
-                    error: result.error.message
-                });
-            }
-            onStackCompleteCallback?.(stack, result.success, duration, result.success ? undefined : result.error);
-            return deploymentResult;
-        }));
-        return success(mapSettledResults(results, stacks));
-    }
-    /**
-     * Destroy a specific stack type
-     */
-    async destroyStack(stackType, context, callbacks, useCdkOut) {
-        const appName = context.target;
-        const stackName = getApplicationStackName(appName, stackType);
-        const result = await this.cdkService.runCdkDestroy(context, stackName, callbacks?.onOutput, callbacks?.onResourceProgress, this.aws, useCdkOut);
-        if (result.success) {
-            return success({
-                stackType,
-                stackName,
-                skipped: false,
-                outputs: undefined
-            });
-        }
-        else {
-            return failure(new ApplicationError(result.error || `Failed to destroy ${stackType} stack`, {
-                errorType: "destroy_failed",
-                appName: context.target,
-                operation: "destroyStack",
-                stackType
-            }));
-        }
-    }
-    /**
-     * Destroy multiple stacks in parallel within a destroy phase.
-     *
-     * IMPORTANT: For parallel operations, useCdkOut must be true and CDK synth must
-     * be run beforehand. Multiple CDK commands cannot run in parallel because they
-     * all try to synthesise to the same cdk.out directory.
-     */
-    async destroyStacksInParallel(stacks, context, callbacks, useCdkOut) {
-        const onOutputCallback = callbacks?.onOutput;
-        const onResourceProgressCallback = callbacks?.onResourceProgress;
-        const onStackCompleteCallback = callbacks?.onStackComplete;
-        const results = await Promise.allSettled(stacks.map(async (stack) => {
-            const startTime = Date.now();
-            const result = await this.destroyStack(stack, context, {
-                onOutput: onOutputCallback
-                    ? (chunk) => onOutputCallback(chunk, stack)
-                    : undefined,
-                onResourceProgress: onResourceProgressCallback
-                    ? (event) => onResourceProgressCallback(event, stack)
-                    : undefined
-            }, useCdkOut);
-            const duration = Date.now() - startTime;
-            const errorMessage = result.success
-                ? ""
-                : (result.error?.message ?? "");
-            const isAlreadyDeleted = errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
-                errorMessage.includes(CDK_NO_STACKS_MATCH);
-            const destroyResult = {
-                stack,
-                success: result.success || isAlreadyDeleted,
-                error: result.success || isAlreadyDeleted ? undefined : result.error,
-                duration
-            };
-            if (!destroyResult.success && destroyResult.error) {
-                logger.debug("destroyStacksInParallel", `Stack ${stack} failed`, {
-                    error: destroyResult.error.message
-                });
-            }
-            onStackCompleteCallback?.(stack, destroyResult.success, duration, destroyResult.success ? undefined : destroyResult.error);
-            return destroyResult;
-        }));
-        return success(mapSettledResults(results, stacks));
-    }
-    /**
-     * Get stack outputs for a deployed stack
-     */
-    async getStackOutputs(appName, stackType) {
-        const stackName = getApplicationStackName(appName, stackType);
-        const result = await this.cloudFormationService.getStackOutputs(stackName);
-        if (!result.success) {
-            return failure(new ApplicationError(`Failed to get outputs for ${stackName}`, {
-                errorType: "stack_error",
-                appName,
-                operation: "getStackOutputs",
-                stackType,
-                details: result.error
-            }));
-        }
-        return success(convertCloudFormationOutputsToRecord(result.data));
-    }
-    /**
-     * Resolve the website URL for an application from CloudFormation stack outputs.
-     * Checks Compute stack for LoadBalancer URL, then CDN stack for CloudFront distribution.
-     */
-    async resolveWebsiteUrl(appName) {
-        return resolveWebsiteUrl(appName, this.cloudFormationService);
-    }
-    /**
-     * Destroy all stacks for an application in reverse order.
-     * Supports parallel destruction for OpenNext patterns (nextjs/payload).
-     */
-    async destroyAllStacks(context, callbacks, resources) {
-        return destroyAllStacks(this, context, callbacks, resources);
-    }
-}
+import{STACK_NOT_FOUND_PATTERN as v,CDK_NO_STACKS_MATCH as P}from"../../types/constants.js";import{getApplicationStackName as y}from"../../types/operations.js";import{success as S,failure as k}from"@fjall/generator";import{ApplicationError as h}from"../../types/application/ApplicationServiceTypes.js";import{logger as m}from"@fjall/util/logger";import{convertCloudFormationOutputsToRecord as w}from"../supporting/helpers.js";import{destroyAllStacks as R,mapSettledResults as O,resolveWebsiteUrl as A}from"./applicationStackHelpers.js";class M{cdkService;cloudFormationService;aws;constructor(e,r,t){this.cdkService=e,this.cloudFormationService=r,this.aws=t}async runCdkSynth(e){return this.cdkService.runCdkSynth(e)}async deployStack(e,r,t){const n=r.target,a=y(n,e),c=await this.cdkService.runCdkDeploy(r,a,t?.onOutput,t?.onResourceProgress,this.aws);if(c.success){const o=c.data;m.debug("ApplicationStackService","CDK deploy result",{stackName:a,stackType:e,success:!0,message:o.message,status:o.status,skipped:o.details?.skipped,hasOutput:!!o.details?.output});const s=await this.cloudFormationService.getStackOutputs(a);m.debug("ApplicationStackService","Stack outputs after deploy",{stackName:a,hasOutputs:s.success&&s.data.length>0,outputCount:s.success?s.data.length:0});const i=s.success&&s.data.length>0?w(s.data):void 0;return S({stackType:e,stackName:a,skipped:o.details?.skipped===!0,outputs:i})}else{const o=c.error||`Failed to deploy ${e} infrastructure`;return m.error("ApplicationStackService","Stack deployment failed",{stackType:e,target:r.target,error:o}),k(new h(o,{errorType:"deployment_failed",appName:r.target,operation:"deployStack",stackType:e}))}}async deployStacksInParallel(e,r,t){const n=t?.onOutput,a=t?.onResourceProgress,c=t?.onStackComplete,o=await Promise.allSettled(e.map(async s=>{const i=Date.now(),u=await this.deployStack(s,r,{onOutput:n?p=>n(p,s):void 0,onResourceProgress:a?p=>a(p,s):void 0}),d=Date.now()-i,g={stack:s,success:u.success,error:u.success?void 0:u.error,duration:d,...u.success&&u.data.outputs!==void 0?{outputs:u.data.outputs}:{}};return!u.success&&u.error&&m.debug("deployStacksInParallel",`Stack ${s} failed`,{error:u.error.message}),c?.(s,u.success,d,u.success?void 0:u.error),g}));return S(O(o,e))}async destroyStack(e,r,t,n){const a=r.target,c=y(a,e),o=await this.cdkService.runCdkDestroy(r,c,t?.onOutput,t?.onResourceProgress,this.aws,n);return o.success?S({stackType:e,stackName:c,skipped:!1,outputs:void 0}):k(new h(o.error||`Failed to destroy ${e} stack`,{errorType:"destroy_failed",appName:r.target,operation:"destroyStack",stackType:e}))}async destroyStacksInParallel(e,r,t,n){const a=t?.onOutput,c=t?.onResourceProgress,o=t?.onStackComplete,s=await Promise.allSettled(e.map(async i=>{const u=Date.now(),d=await this.destroyStack(i,r,{onOutput:a?f=>a(f,i):void 0,onResourceProgress:c?f=>c(f,i):void 0},n),g=Date.now()-u,p=d.success?"":d.error?.message??"",C=p.includes(v)||p.includes(P),l={stack:i,success:d.success||C,error:d.success||C?void 0:d.error,duration:g};return!l.success&&l.error&&m.debug("destroyStacksInParallel",`Stack ${i} failed`,{error:l.error.message}),o?.(i,l.success,g,l.success?void 0:l.error),l}));return S(O(s,e))}async getStackOutputs(e,r){const t=y(e,r),n=await this.cloudFormationService.getStackOutputs(t);return n.success?S(w(n.data)):k(new h(`Failed to get outputs for ${t}`,{errorType:"stack_error",appName:e,operation:"getStackOutputs",stackType:r,details:n.error}))}async resolveWebsiteUrl(e){return A(e,this.cloudFormationService)}async destroyAllStacks(e,r,t){return R(this,e,r,t)}}export{M as ApplicationStackService};

package/dist/src/services/application/applicationStackHelpers.js

@@ -1,248 +1,4 @@
-import { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH, INFRASTRUCTURE_FILENAME } from "../../types/constants.js";
-import { APPLICATION_STACKS, getApplicationStackName, getApplicationDestroyOrder, getParallelDestroyGroups } from "../../types/operations.js";
-import { FrameworkRegistry } from "../../orchestration/builders/frameworkRegistry.js";
-import { success, failure, isFailure } from "@fjall/generator";
-import { ApplicationError } from "../../types/application/ApplicationServiceTypes.js";
-import { logger } from "@fjall/util/logger";
-/**
- * Convert "doesn't exist" errors to success for destroy operations.
- */
-export function convertDestroyResultIfNotExists(result, stackType, appName) {
-    if (result.success)
-        return result;
-    const errorMessage = isFailure(result) ? result.error.message : "";
-    const isAlreadyDeleted = errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
-        errorMessage.includes(CDK_NO_STACKS_MATCH);
-    if (isAlreadyDeleted) {
-        return success({
-            stackName: getApplicationStackName(appName, stackType),
-            stackType,
-            outputs: {},
-            skipped: true
-        });
-    }
-    return result;
-}
-/**
- * Handle destroy errors and determine if we should continue or fail
- */
-export function handleDestroyError(result, stackType) {
-    if (result.success)
-        return null;
-    const errorMessage = isFailure(result) ? result.error.message : "";
-    if (errorMessage.includes("TSError") ||
-        errorMessage.includes("Unable to compile TypeScript") ||
-        errorMessage.includes("Subprocess exited with error")) {
-        const tsErrorMatch = errorMessage.match(/infrastructure\.ts\(\d+,\d+\): error TS\d+: .+/);
-        const errorDetail = tsErrorMatch
-            ? tsErrorMatch[0]
-            : `Check ${INFRASTRUCTURE_FILENAME} for syntax errors`;
-        return {
-            continue: false,
-            result: failure(new ApplicationError(`CDK synthesis failed: ${errorDetail}`, {
-                errorType: "synth_failed",
-                operation: `destroy-${stackType}`
-            }))
-        };
-    }
-    if (errorMessage.includes(STACK_NOT_FOUND_PATTERN) ||
-        errorMessage.includes(CDK_NO_STACKS_MATCH)) {
-        return {
-            continue: true,
-            result: success({ message: "Stack already deleted" })
-        };
-    }
-    return {
-        continue: false,
-        result: failure(new ApplicationError(`Failed to destroy ${stackType} stack: ${errorMessage}`, {
-            errorType: "destroy_failed",
-            operation: `destroy-${stackType}`
-        }))
-    };
-}
-/**
- * Destroy all stacks for an application in reverse order.
- * Supports parallel destruction for OpenNext patterns (nextjs/payload).
- */
-export async function destroyAllStacks(service, context, callbacks, resources) {
-    const appName = context.target;
-    // Use FrameworkRegistry to resolve builder and plan
-    const registry = FrameworkRegistry.createDefault();
-    const resolved = registry.resolve({ appPath: context.path });
-    // Determine destroy strategy from builder plan if available, else fall back to pattern detection
-    let useParallelDestroy;
-    let destroyOrder;
-    if (resolved) {
-        const plan = resolved.builder.plan({ appPath: context.path }, resolved.detection);
-        useParallelDestroy = plan.parallelDestroy;
-        destroyOrder = plan.destroyOrder;
-    }
-    else {
-        // No builder matched — infrastructure.ts missing. Use sequential destroy with default order.
-        useParallelDestroy = false;
-        destroyOrder = getApplicationDestroyOrder({ pattern: null, resources });
-    }
-    if (useParallelDestroy) {
-        const destroyGroups = getParallelDestroyGroups();
-        for (const group of destroyGroups) {
-            const stacks = group.stacks;
-            if (stacks.length === 1) {
-                const stackType = stacks[0];
-                const stackName = getApplicationStackName(appName, stackType);
-                callbacks?.onStackStart?.(stackType, stackName);
-                const result = await service.destroyStack(stackType, context, {
-                    onOutput: callbacks?.onOutput
-                        ? (chunk) => callbacks.onOutput?.(chunk, stackType)
-                        : undefined,
-                    onResourceProgress: callbacks?.onResourceProgress
-                        ? (event) => callbacks.onResourceProgress?.(event, stackType)
-                        : undefined
-                });
-                const finalResult = convertDestroyResultIfNotExists(result, stackType, appName);
-                if (callbacks?.onStackComplete) {
-                    await callbacks.onStackComplete(stackType, finalResult);
-                }
-                const errorResult = handleDestroyError(finalResult, stackType);
-                if (errorResult) {
-                    if (errorResult.continue)
-                        continue;
-                    return errorResult.result;
-                }
-            }
-            else {
-                const synthResult = await service.runCdkSynth(context);
-                if (!synthResult.success) {
-                    return failure(new ApplicationError(synthResult.error, {
-                        errorType: "synth_failed",
-                        appName,
-                        operation: "destroy-parallel-synth"
-                    }));
-                }
-                callbacks?.onParallelPhaseStart?.(stacks, group.description);
-                for (const stackType of stacks) {
-                    callbacks?.onStackStart?.(stackType, getApplicationStackName(appName, stackType));
-                }
-                const parallelResult = await service.destroyStacksInParallel(stacks, context, {
-                    onOutput: callbacks?.onOutput,
-                    onResourceProgress: callbacks?.onResourceProgress,
-                    onStackComplete: async (stack, stackSuccess, _duration, error) => {
-                        const result = stackSuccess
-                            ? success({
-                                stackName: getApplicationStackName(appName, stack),
-                                stackType: stack,
-                                outputs: {}
-                            })
-                            : failure(error instanceof ApplicationError
-                                ? error
-                                : new ApplicationError(error?.message ?? "Stack destruction failed", {
-                                    errorType: "destroy_failed",
-                                    appName,
-                                    operation: `destroy-${stack}`
-                                }));
-                        await callbacks?.onStackComplete?.(stack, result);
-                    }
-                }, true);
-                if (parallelResult.success) {
-                    callbacks?.onParallelPhaseComplete?.(parallelResult.data);
-                    const failures = parallelResult.data.filter((r) => !r.success);
-                    if (failures.length > 0) {
-                        const realFailures = failures.filter((f) => f.error &&
-                            !f.error.message.includes(STACK_NOT_FOUND_PATTERN) &&
-                            !f.error.message.includes(CDK_NO_STACKS_MATCH));
-                        if (realFailures.length > 0) {
-                            const failedStacks = realFailures.map((f) => f.stack).join(", ");
-                            const errorDetails = realFailures
-                                .map((f) => `${f.stack}: ${f.error?.message || "Unknown error"}`)
-                                .join("\n");
-                            return failure(new ApplicationError(`Failed to destroy stacks: ${failedStacks}\n\n${errorDetails}`, {
-                                errorType: "destroy_failed",
-                                appName,
-                                operation: "destroy-parallel"
-                            }));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else {
-        for (const stackType of destroyOrder) {
-            const stackName = getApplicationStackName(appName, stackType);
-            callbacks?.onStackStart?.(stackType, stackName);
-            const result = await service.destroyStack(stackType, context, {
-                onOutput: callbacks?.onOutput
-                    ? (chunk) => callbacks.onOutput?.(chunk, stackType)
-                    : undefined,
-                onResourceProgress: callbacks?.onResourceProgress
-                    ? (event) => callbacks.onResourceProgress?.(event, stackType)
-                    : undefined
-            });
-            const finalResult = convertDestroyResultIfNotExists(result, stackType, appName);
-            if (callbacks?.onStackComplete) {
-                await callbacks.onStackComplete(stackType, finalResult);
-            }
-            const errorResult = handleDestroyError(finalResult, stackType);
-            if (errorResult) {
-                if (errorResult.continue)
-                    continue;
-                return errorResult.result;
-            }
-        }
-    }
-    return success({ message: "All stacks destroyed" });
-}
-/**
- * Map Promise.allSettled results to ParallelDeploymentResult[], handling
- * rejected promises with a fallback stack identity.
- */
-export function mapSettledResults(settled, stacks) {
-    return settled.map((settledResult, index) => {
-        if (settledResult.status === "fulfilled") {
-            return settledResult.value;
-        }
-        const stack = stacks[index] ?? APPLICATION_STACKS.NETWORK;
-        return {
-            stack,
-            success: false,
-            error: settledResult.reason instanceof Error
-                ? settledResult.reason
-                : new Error(String(settledResult.reason)),
-            duration: 0
-        };
-    });
-}
-/**
- * Resolve the website URL for an application from CloudFormation stack outputs.
- * Checks Compute stack for LoadBalancer URL, then CDN stack for CloudFront distribution.
- */
-export async function resolveWebsiteUrl(appName, cloudFormationService) {
-    try {
-        const computeStackName = getApplicationStackName(appName, APPLICATION_STACKS.COMPUTE);
-        const computeOutputs = await cloudFormationService.getStackOutputs(computeStackName);
-        if (computeOutputs.success && computeOutputs.data.length > 0) {
-            const lbUrl = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerUrl"));
-            if (lbUrl?.OutputValue) {
-                return lbUrl.OutputValue.toLowerCase();
-            }
-            const lbDns = computeOutputs.data.find((o) => o.OutputKey?.includes("LoadBalancerDnsName"));
-            if (lbDns?.OutputValue) {
-                return `http://${lbDns.OutputValue.toLowerCase()}`;
-            }
-        }
-        const cdnStackName = getApplicationStackName(appName, APPLICATION_STACKS.CDN);
-        const cdnOutputs = await cloudFormationService.getStackOutputs(cdnStackName);
-        if (cdnOutputs.success && cdnOutputs.data.length > 0) {
-            const dist = cdnOutputs.data.find((o) => o.OutputKey?.includes("DistributionDomainName"));
-            if (dist?.OutputValue) {
-                return `https://${dist.OutputValue.toLowerCase()}`;
-            }
-        }
-        return undefined;
-    }
-    catch (error) {
-        logger.warn("ApplicationStackService", "URL resolution failed", {
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return undefined;
-    }
-}
+import{STACK_NOT_FOUND_PATTERN as T,CDK_NO_STACKS_MATCH as k,INFRASTRUCTURE_FILENAME as E}from"../../types/constants.js";import{APPLICATION_STACKS as D,getApplicationStackName as S,getApplicationDestroyOrder as _,getParallelDestroyGroups as $}from"../../types/operations.js";import{FrameworkRegistry as U}from"../../orchestration/builders/frameworkRegistry.js";import{success as P,failure as h,isFailure as N}from"@fjall/generator";import{ApplicationError as O}from"../../types/application/ApplicationServiceTypes.js";import{logger as K}from"@fjall/util/logger";function R(t,r,e){if(t.success)return t;const n=N(t)?t.error.message:"";return n.includes(T)||n.includes(k)?P({stackName:S(e,r),stackType:r,outputs:{},skipped:!0}):t}function A(t,r){if(t.success)return null;const e=N(t)?t.error.message:"";if(e.includes("TSError")||e.includes("Unable to compile TypeScript")||e.includes("Subprocess exited with error")){const n=e.match(/infrastructure\.ts\(\d+,\d+\): error TS\d+: .+/),s=n?n[0]:`Check ${E} for syntax errors`;return{continue:!1,result:h(new O(`CDK synthesis failed: ${s}`,{errorType:"synth_failed",operation:`destroy-${r}`}))}}return e.includes(T)||e.includes(k)?{continue:!0,result:P({message:"Stack already deleted"})}:{continue:!1,result:h(new O(`Failed to destroy ${r} stack: ${e}`,{errorType:"destroy_failed",operation:`destroy-${r}`}))}}async function v(t,r,e,n){const s=r.target,l=U.createDefault().resolve({appPath:r.path});let f,y;if(l){const u=l.builder.plan({appPath:r.path},l.detection);f=u.parallelDestroy,y=u.destroyOrder}else f=!1,y=_({pattern:null,resources:n});if(f){const u=$();for(const C of u){const m=C.stacks;if(m.length===1){const a=m[0],p=S(s,a);e?.onStackStart?.(a,p);const o=await t.destroyStack(a,r,{onOutput:e?.onOutput?d=>e.onOutput?.(d,a):void 0,onResourceProgress:e?.onResourceProgress?d=>e.onResourceProgress?.(d,a):void 0}),i=R(o,a,s);e?.onStackComplete&&await e.onStackComplete(a,i);const c=A(i,a);if(c){if(c.continue)continue;return c.result}}else{const a=await t.runCdkSynth(r);if(!a.success)return h(new O(a.error,{errorType:"synth_failed",appName:s,operation:"destroy-parallel-synth"}));e?.onParallelPhaseStart?.(m,C.description);for(const o of m)e?.onStackStart?.(o,S(s,o));const p=await t.destroyStacksInParallel(m,r,{onOutput:e?.onOutput,onResourceProgress:e?.onResourceProgress,onStackComplete:async(o,i,c,d)=>{const g=i?P({stackName:S(s,o),stackType:o,outputs:{}}):h(d instanceof O?d:new O(d?.message??"Stack destruction failed",{errorType:"destroy_failed",appName:s,operation:`destroy-${o}`}));await e?.onStackComplete?.(o,g)}},!0);if(p.success){e?.onParallelPhaseComplete?.(p.data);const o=p.data.filter(i=>!i.success);if(o.length>0){const i=o.filter(c=>c.error&&!c.error.message.includes(T)&&!c.error.message.includes(k));if(i.length>0){const c=i.map(g=>g.stack).join(", "),d=i.map(g=>`${g.stack}: ${g.error?.message||"Unknown error"}`).join(`
+`);return h(new O(`Failed to destroy stacks: ${c}
+
+${d}`,{errorType:"destroy_failed",appName:s,operation:"destroy-parallel"}))}}}}}}else for(const u of y){const C=S(s,u);e?.onStackStart?.(u,C);const m=await t.destroyStack(u,r,{onOutput:e?.onOutput?o=>e.onOutput?.(o,u):void 0,onResourceProgress:e?.onResourceProgress?o=>e.onResourceProgress?.(o,u):void 0}),a=R(m,u,s);e?.onStackComplete&&await e.onStackComplete(u,a);const p=A(a,u);if(p){if(p.continue)continue;return p.result}}return P({message:"All stacks destroyed"})}function x(t,r){return t.map((e,n)=>e.status==="fulfilled"?e.value:{stack:r[n]??D.NETWORK,success:!1,error:e.reason instanceof Error?e.reason:new Error(String(e.reason)),duration:0})}async function B(t,r){try{const e=S(t,D.COMPUTE),n=await r.getStackOutputs(e);if(n.success&&n.data.length>0){const l=n.data.find(y=>y.OutputKey?.includes("LoadBalancerUrl"));if(l?.OutputValue)return l.OutputValue.toLowerCase();const f=n.data.find(y=>y.OutputKey?.includes("LoadBalancerDnsName"));if(f?.OutputValue)return`http://${f.OutputValue.toLowerCase()}`}const s=S(t,D.CDN),w=await r.getStackOutputs(s);if(w.success&&w.data.length>0){const l=w.data.find(f=>f.OutputKey?.includes("DistributionDomainName"));if(l?.OutputValue)return`https://${l.OutputValue.toLowerCase()}`}return}catch(e){K.warn("ApplicationStackService","URL resolution failed",{error:e instanceof Error?e.message:String(e)});return}}export{R as convertDestroyResultIfNotExists,v as destroyAllStacks,A as handleDestroyError,x as mapSettledResults,B as resolveWebsiteUrl};