@fjall/deploy-core 0.89.2

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

@@ -0,0 +1,436 @@
+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 { detectPattern, isOpenNextPattern } from "../../types/patternDetection.js";
+import { success, failure, isFailure } from "@fjall/generator";
+import { ApplicationError } from "../../types/application/ApplicationServiceTypes.js";
+import { logger } from "@fjall/util";
+import { convertCloudFormationOutputsToRecord } from "../supporting/helpers.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) {
+        this.cdkService = cdkService;
+        this.cloudFormationService = cloudFormationService;
+    }
+    setAwsContext(aws) {
+        this.aws = aws;
+    }
+    /**
+     * 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;
+        }));
+        const deployResults = results.map((settledResult, index) => {
+            if (settledResult.status === "fulfilled") {
+                return settledResult.value;
+            }
+            return {
+                stack: stacks[index],
+                success: false,
+                error: settledResult.reason instanceof Error
+                    ? settledResult.reason
+                    : new Error(String(settledResult.reason)),
+                duration: 0
+            };
+        });
+        return success(deployResults);
+    }
+    /**
+     * 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;
+        }));
+        const destroyResults = results.map((settledResult, index) => {
+            if (settledResult.status === "fulfilled") {
+                return settledResult.value;
+            }
+            return {
+                stack: stacks[index],
+                success: false,
+                error: settledResult.reason instanceof Error
+                    ? settledResult.reason
+                    : new Error(String(settledResult.reason)),
+                duration: 0
+            };
+        });
+        return success(destroyResults);
+    }
+    /**
+     * 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) {
+        try {
+            const computeStackName = getApplicationStackName(appName, APPLICATION_STACKS.COMPUTE);
+            const computeOutputs = await this.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 this.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.debug("ApplicationStackService", "URL resolution failed", {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return undefined;
+        }
+    }
+    /**
+     * Destroy all stacks for an application in reverse order.
+     * Supports parallel destruction for OpenNext patterns (nextjs/payload).
+     */
+    async destroyAllStacks(context, callbacks, resources) {
+        const patternResult = detectPattern(context.path);
+        const pattern = patternResult.pattern;
+        const appName = context.target;
+        if (isOpenNextPattern(pattern)) {
+            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 this.destroyStack(stackType, context, {
+                        onOutput: callbacks?.onOutput
+                            ? (chunk) => callbacks.onOutput?.(chunk, stackType)
+                            : undefined,
+                        onResourceProgress: callbacks?.onResourceProgress
+                            ? (event) => callbacks.onResourceProgress?.(event, stackType)
+                            : undefined
+                    });
+                    const finalResult = this.convertDestroyResultIfNotExists(result, stackType, appName);
+                    if (callbacks?.onStackComplete) {
+                        await callbacks.onStackComplete(stackType, finalResult);
+                    }
+                    const errorResult = this.handleDestroyError(finalResult, stackType);
+                    if (errorResult) {
+                        if (errorResult.continue)
+                            continue;
+                        return errorResult.result;
+                    }
+                }
+                else {
+                    const synthResult = await this.cdkService.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 this.destroyStacksInParallel(stacks, context, {
+                        onOutput: callbacks?.onOutput,
+                        onResourceProgress: callbacks?.onResourceProgress,
+                        onStackComplete: async (stack, stackSuccess, _duration, error) => {
+                            const result = stackSuccess
+                                ? success({
+                                    stackName: `${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 {
+            const stackOrder = getApplicationDestroyOrder({ pattern, resources });
+            for (const stackType of stackOrder) {
+                const stackName = getApplicationStackName(appName, stackType);
+                callbacks?.onStackStart?.(stackType, stackName);
+                const result = await this.destroyStack(stackType, context, {
+                    onOutput: callbacks?.onOutput
+                        ? (chunk) => callbacks.onOutput?.(chunk, stackType)
+                        : undefined,
+                    onResourceProgress: callbacks?.onResourceProgress
+                        ? (event) => callbacks.onResourceProgress?.(event, stackType)
+                        : undefined
+                });
+                const finalResult = this.convertDestroyResultIfNotExists(result, stackType, appName);
+                if (callbacks?.onStackComplete) {
+                    await callbacks.onStackComplete(stackType, finalResult);
+                }
+                const errorResult = this.handleDestroyError(finalResult, stackType);
+                if (errorResult) {
+                    if (errorResult.continue)
+                        continue;
+                    return errorResult.result;
+                }
+            }
+        }
+        return success({ message: "All stacks destroyed" });
+    }
+    /**
+     * Convert "doesn't exist" errors to success for destroy operations.
+     */
+    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: {}
+            });
+        }
+        return result;
+    }
+    /**
+     * Handle destroy errors and determine if we should continue or fail
+     */
+    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}`
+            }))
+        };
+    }
+}

package/dist/src/services/application/index.d.ts

@@ -0,0 +1 @@
+export { ApplicationStackService } from "./ApplicationStackService.js";

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

@@ -0,0 +1 @@
+export { ApplicationStackService } from "./ApplicationStackService.js";

package/dist/src/services/infrastructure/CdkArgumentBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { CdkContext, CdkOptions } from "./CdkService.js";
+export declare class CdkArgumentBuilder {
+    buildContextArgs(context?: CdkContext): string[];
+    injectCascadeCredentials(env: NodeJS.ProcessEnv, credentials?: CdkOptions["credentials"]): void;
+    buildCdkEnv(options?: {
+        context?: {
+            region?: string;
+            accountId?: string;
+        };
+        credentials?: CdkOptions["credentials"];
+    }): NodeJS.ProcessEnv;
+}

package/dist/src/services/infrastructure/CdkArgumentBuilder.js

@@ -0,0 +1,67 @@
+import { filterDangerousEnvVars } from "../../util/securityHelpers.js";
+export class CdkArgumentBuilder {
+    buildContextArgs(context) {
+        const args = [];
+        if (context?.accountId) {
+            args.push("-c", `accountId=${context.accountId}`);
+        }
+        if (context?.environment) {
+            args.push("-c", `environment=${context.environment}`);
+        }
+        if (context?.managedAccount) {
+            args.push("-c", "managedAccount=true");
+        }
+        if (context?.accountName) {
+            args.push("-c", `accountName=${context.accountName}`);
+        }
+        if (context?.imageVersion) {
+            args.push("-c", `imageVersion=${context.imageVersion}`);
+        }
+        if (context?.orgId) {
+            args.push("-c", `orgId=${context.orgId}`);
+        }
+        if (context?.rootId) {
+            args.push("-c", `rootId=${context.rootId}`);
+        }
+        if (context?.managementAccountId) {
+            args.push("-c", `managementAccountId=${context.managementAccountId}`);
+        }
+        if (context?.ipamPoolId) {
+            args.push("-c", `ipamPoolId=${context.ipamPoolId}`);
+        }
+        if (context?.fjallOrgId) {
+            args.push("-c", `fjallOrgId=${context.fjallOrgId}`);
+        }
+        if (context?.orgConfig) {
+            args.push("-c", `orgConfig=${context.orgConfig}`);
+        }
+        return args;
+    }
+    injectCascadeCredentials(env, credentials) {
+        if (credentials) {
+            env.AWS_ACCESS_KEY_ID = credentials.accessKeyId;
+            env.AWS_SECRET_ACCESS_KEY = credentials.secretAccessKey;
+            if (credentials.sessionToken) {
+                env.AWS_SESSION_TOKEN = credentials.sessionToken;
+            }
+        }
+    }
+    buildCdkEnv(options) {
+        const env = {
+            ...filterDangerousEnvVars(process.env),
+            CI: "true",
+            FORCE_COLOR: "0",
+            CDK_DISABLE_VERSION_CHECK: "1"
+        };
+        if (options?.context?.region) {
+            env.AWS_REGION = options.context.region;
+            env.AWS_DEFAULT_REGION = options.context.region;
+            env.CDK_DEFAULT_REGION = options.context.region;
+        }
+        if (options?.context?.accountId) {
+            env.CDK_DEFAULT_ACCOUNT = options.context.accountId;
+        }
+        this.injectCascadeCredentials(env, options?.credentials);
+        return env;
+    }
+}

package/dist/src/services/infrastructure/CdkCommandRunner.d.ts

@@ -0,0 +1,30 @@
+import type { Result } from "@fjall/generator";
+import { CdkError } from "../../types/errors/CdkError.js";
+import { type DiffDetails } from "./CdkOutputParser.js";
+import type { CdkOptions, CdkOutput } from "./CdkService.js";
+export interface CheckDifferencesResult {
+    hasDifferences: boolean;
+    output?: string;
+    details?: DiffDetails;
+}
+/**
+ * Runs low-level CDK CLI commands (synth, deploy, destroy, diff, bootstrap, import).
+ * Delegates process management to CdkProcessManager.
+ */
+export declare class CdkCommandRunner {
+    private processManager;
+    constructor();
+    checkDifferences(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CheckDifferencesResult, CdkError>>;
+    deploy(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    destroy(path: string, stackName?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    /**
+     * Import existing AWS resources into CDK stack
+     *
+     * NOTE: This method is fully functional but currently unreachable as import
+     * functionality is temporarily disabled at the AST layer (astCodeModification.ts).
+     * When import is re-enabled, this method will work without changes.
+     */
+    runImport(path: string, resourceMappingFile?: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    synth(path: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+    bootstrap(accountId: string, region: string, options?: CdkOptions): Promise<Result<CdkOutput, string>>;
+}