@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/orchestration/applicationDestroy.js

@@ -0,0 +1,131 @@
+import { success, failure } from "@fjall/generator";
+import { logger } from "@fjall/util/logger";
+import { getApplicationDestroyOrder, getApplicationStepName, getApplicationStepId } from "../types/operations.js";
+import { stubCallerIdentity } from "../types/deployment/index.js";
+import { deriveResourcesFromManifestStacks } from "../types/patternDetection.js";
+import { CdkContextBuilder } from "../services/supporting/CdkContextBuilder.js";
+import { buildParamsContext } from "./contextHelpers.js";
+import { deleteStateFile, readStateFile } from "../types/FjallState.js";
+/**
+ * Core application destruction orchestration.
+ *
+ * Detects application pattern, determines destroy order (reverse of deploy),
+ * then destroys stacks sequentially or in parallel groups. Delegates all
+ * CDK operations to the ApplicationStackService.destroyAllStacks() method,
+ * which handles "stack doesn't exist" → success conversion and parallel
+ * phase orchestration for OpenNext patterns.
+ */
+export async function destroyApplication(params, services, operation) {
+    const { callbacks } = params;
+    const startTime = Date.now();
+    // 1. Detect pattern for correct destroy order
+    const resolved = services.frameworkRegistry.resolve({
+        appPath: operation.path
+    });
+    const pattern = resolved?.detection.pattern ?? null;
+    // Derive resources from state file (if available from prior deploy)
+    let destroyResources;
+    try {
+        const stateFile = await readStateFile(operation.path);
+        if (stateFile !== null) {
+            const stackNames = Object.keys(stateFile.templateHashes);
+            if (stackNames.length > 0) {
+                destroyResources = deriveResourcesFromManifestStacks(stackNames);
+            }
+        }
+    }
+    catch (err) {
+        logger.debug("applicationDestroy", "Could not read state file for resource detection", { error: err instanceof Error ? err.message : String(err) });
+        callbacks.onLog?.("Could not read state file for resource detection — falling back to pattern detection", "warn");
+    }
+    // 2. Build deployment context
+    const context = CdkContextBuilder.buildDeploymentContext({
+        deployType: "application",
+        target: operation.appName,
+        path: operation.path,
+        region: services.awsProvider.getRegion(),
+        callerIdentity: stubCallerIdentity(services.awsProvider.getAccountId()),
+        ...buildParamsContext({
+            orgConfig: params.orgConfig,
+            identity: params.identity
+        })
+    }, {
+        verbose: params.options?.verbose
+    }, params.orgConfig);
+    // 3. Determine destroy order
+    const destroyOrder = getApplicationDestroyOrder({
+        pattern,
+        resources: destroyResources
+    });
+    const totalSteps = destroyOrder.length;
+    callbacks.onLog?.(`Destroying ${operation.appName} (${totalSteps} stacks, ${pattern ?? "standard"} pattern)`, "info");
+    // 4. Destroy stacks via ApplicationStackService
+    const stacksDestroyed = [];
+    const skippedStacks = [];
+    const destroyResult = await services.stackService.destroyAllStacks(context, {
+        onOutput: (chunk) => {
+            callbacks.onOutput?.(chunk);
+        },
+        onResourceProgress: (event, stackId) => {
+            callbacks.onResourceProgress?.(event);
+            if (stackId) {
+                callbacks.onParallelStackResourceProgress?.(stackId, event);
+            }
+        },
+        onStackStart: (stackType, _stackName) => {
+            const stepId = getApplicationStepId(stackType, "destroy");
+            const stepName = getApplicationStepName(stackType, "destroy");
+            const stepIndex = destroyOrder.indexOf(stackType);
+            callbacks.onStepStart?.(stepId, stepName, stepIndex, totalSteps);
+        },
+        onStackComplete: async (stackType, result) => {
+            const stepId = getApplicationStepId(stackType, "destroy");
+            const stepName = getApplicationStepName(stackType, "destroy");
+            const stepIndex = destroyOrder.indexOf(stackType);
+            if (result.success) {
+                if (result.data?.skipped) {
+                    skippedStacks.push(result.data.stackName || stackType);
+                    callbacks.onStepComplete?.(stepId, stepName, "skipped", stepIndex, totalSteps);
+                }
+                else {
+                    stacksDestroyed.push(result.data?.stackName || stackType);
+                    callbacks.onStepComplete?.(stepId, stepName, "completed", stepIndex, totalSteps);
+                }
+            }
+            else {
+                callbacks.onStepComplete?.(stepId, stepName, "error", stepIndex, totalSteps);
+                callbacks.onError?.(result.error);
+            }
+        },
+        onParallelPhaseStart: (stacks, description) => {
+            callbacks.onLog?.(`Parallel phase: ${description}`, "info");
+            callbacks.onParallelPhaseStart?.(stacks, description);
+        },
+        onParallelPhaseComplete: (results) => {
+            const failed = results.filter((r) => !r.success);
+            if (failed.length > 0) {
+                callbacks.onLog?.(`Parallel phase completed with ${failed.length} failure(s)`, "warn");
+            }
+            callbacks.onParallelPhaseComplete?.(results);
+        }
+    }, destroyResources);
+    if (!destroyResult.success) {
+        callbacks.onError?.(destroyResult.error);
+        return failure(destroyResult.error);
+    }
+    // 5. Clean up state file after successful destroy
+    try {
+        await deleteStateFile(operation.path);
+    }
+    catch (err) {
+        logger.debug("applicationDestroy", "Failed to delete state file (non-critical)", { error: err instanceof Error ? err.message : String(err) });
+        callbacks.onLog?.("Failed to delete state file (non-critical)", "warn");
+    }
+    return success({
+        target: operation.appName,
+        deploymentType: "application",
+        stacksDestroyed,
+        skippedStacks,
+        durationMs: Date.now() - startTime
+    });
+}

package/dist/src/orchestration/builders/dockerBuilder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DockerBuilder — FrameworkBuilder implementation for standard Docker apps.
+ *
+ * Fallback builder (priority 100) that detects any Fjall app with an
+ * infrastructure.ts file. Docker builds are NOT handled here — they are
+ * handled by DockerProvider in the orchestration layer. This builder only
+ * produces the deployment plan and resource detection.
+ */
+import type { FrameworkBuilder } from "../../types/frameworkBuilder.js";
+/**
+ * Docker FrameworkBuilder for standard containerised applications.
+ *
+ * Priority 100 — checked last as the fallback builder. Any Fjall app with
+ * an infrastructure.ts file is a valid Docker app unless a higher-priority
+ * builder (e.g. OpenNext) claims it first.
+ */
+export declare const dockerBuilder: FrameworkBuilder;

package/dist/src/orchestration/builders/dockerBuilder.js

@@ -0,0 +1,98 @@
+/**
+ * DockerBuilder — FrameworkBuilder implementation for standard Docker apps.
+ *
+ * Fallback builder (priority 100) that detects any Fjall app with an
+ * infrastructure.ts file. Docker builds are NOT handled here — they are
+ * handled by DockerProvider in the orchestration layer. This builder only
+ * produces the deployment plan and resource detection.
+ */
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { success } from "@fjall/generator";
+import { logger } from "@fjall/util/logger";
+import { getErrorMessage } from "@fjall/util";
+import { hasDockerfile } from "../../util/dockerfileDetection.js";
+import { INFRASTRUCTURE_FILENAME } from "../../types/constants.js";
+import { getApplicationDeployOrder, getApplicationDestroyOrder } from "../../types/operations.js";
+/** Default resources when infrastructure.ts cannot be parsed */
+const DEFAULT_RESOURCES = {
+    hasNetwork: true,
+    hasCompute: true,
+    hasDatabase: false,
+    hasStorage: false,
+    hasMessaging: false,
+    hasCdn: false
+};
+/**
+ * Read infrastructure.ts and derive resource flags from its content.
+ */
+function detectResources(appPath) {
+    try {
+        const filePath = join(appPath, INFRASTRUCTURE_FILENAME);
+        if (!existsSync(filePath))
+            return { exists: false, hasDatabase: false };
+        const content = readFileSync(filePath, "utf-8");
+        const hasDatabase = content.includes("DatabaseFactory.build(");
+        return { exists: true, hasDatabase };
+    }
+    catch (error) {
+        logger.debug("dockerBuilder", "Failed to read infrastructure file", {
+            appPath,
+            error: getErrorMessage(error)
+        });
+        return { exists: false, hasDatabase: false };
+    }
+}
+/**
+ * Docker FrameworkBuilder for standard containerised applications.
+ *
+ * Priority 100 — checked last as the fallback builder. Any Fjall app with
+ * an infrastructure.ts file is a valid Docker app unless a higher-priority
+ * builder (e.g. OpenNext) claims it first.
+ */
+export const dockerBuilder = {
+    name: "docker",
+    priority: 100,
+    detect(context) {
+        const { exists, hasDatabase } = detectResources(context.appPath);
+        if (!exists) {
+            return {
+                detected: false,
+                pattern: null,
+                reason: "No infrastructure.ts found",
+                resources: DEFAULT_RESOURCES,
+                hasDatabase: false,
+                hasDockerfile: false
+            };
+        }
+        const dockerfile = hasDockerfile(context.appPath);
+        return {
+            detected: true,
+            pattern: null,
+            reason: dockerfile
+                ? "infrastructure.ts found with Dockerfile"
+                : "infrastructure.ts found (no Dockerfile)",
+            resources: { ...DEFAULT_RESOURCES, hasDatabase },
+            hasDatabase,
+            hasDockerfile: dockerfile
+        };
+    },
+    plan(_context, detection) {
+        const resources = detection.resources;
+        return {
+            builderName: "docker",
+            deployOrder: getApplicationDeployOrder({ resources }),
+            destroyOrder: getApplicationDestroyOrder({ resources }),
+            parallelDestroy: false,
+            preBuildCommands: [],
+            buildCommand: null,
+            requiresDockerBuild: detection.hasDockerfile,
+            resources
+        };
+    },
+    async build(_appPath, _plan, _callbacks, _options) {
+        // Docker builds are handled by DockerProvider in the orchestration layer,
+        // not by the builder. This is the correct separation of concerns.
+        return success(undefined);
+    }
+};

package/dist/src/orchestration/builders/frameworkRegistry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * FrameworkRegistry — resolves which FrameworkBuilder handles an application.
+ *
+ * Builders are registered with a priority (lower = higher precedence) and
+ * checked in order. The first builder whose `detect()` returns `detected: true`
+ * wins. A config override bypasses detection and forces selection by name.
+ */
+import type { FrameworkBuilder, FrameworkDetection, DetectionContext } from "../../types/frameworkBuilder.js";
+/** Result of resolving a builder for an application */
+export interface ResolvedBuilder {
+    readonly builder: FrameworkBuilder;
+    readonly detection: FrameworkDetection;
+}
+export declare class FrameworkRegistry {
+    private readonly builders;
+    private constructor();
+    /** Resolve which builder handles this app */
+    resolve(context: DetectionContext, configOverride?: string): ResolvedBuilder | null;
+    /** Create a registry with all built-in builders */
+    static createDefault(): FrameworkRegistry;
+    /** Create with custom builders (for testing) */
+    static create(builders: FrameworkBuilder[]): FrameworkRegistry;
+}

package/dist/src/orchestration/builders/frameworkRegistry.js

@@ -0,0 +1 @@
+import{openNextBuilder as u}from"./openNextBuilder.js";import{dockerBuilder as d}from"./dockerBuilder.js";class n{builders;constructor(e){this.builders=[...e].sort((r,t)=>r.priority-t.priority)}resolve(e,r){if(r){const t=this.builders.find(o=>o.name===r);if(!t)return null;const i=t.detect(e);return{builder:t,detection:{...i,detected:!0}}}for(const t of this.builders){const i=t.detect(e);if(i.detected)return{builder:t,detection:i}}return null}static createDefault(){return new n([u,d])}static create(e){return new n(e)}}export{n as FrameworkRegistry};

package/dist/src/orchestration/builders/index.d.ts

@@ -0,0 +1,4 @@
+export { dockerBuilder } from "./dockerBuilder.js";
+export { openNextBuilder } from "./openNextBuilder.js";
+export { FrameworkRegistry } from "./frameworkRegistry.js";
+export type { ResolvedBuilder } from "./frameworkRegistry.js";

package/dist/src/orchestration/builders/index.js

@@ -0,0 +1 @@
+import{dockerBuilder as o}from"./dockerBuilder.js";import{openNextBuilder as m}from"./openNextBuilder.js";import{FrameworkRegistry as x}from"./frameworkRegistry.js";export{x as FrameworkRegistry,o as dockerBuilder,m as openNextBuilder};

package/dist/src/orchestration/builders/openNextBuilder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * OpenNextBuilder — FrameworkBuilder implementation for Next.js and Payload apps.
+ *
+ * Detects OpenNext patterns from infrastructure.ts, produces a build plan with
+ * the correct stack ordering, and delegates build execution to `runOpenNextBuild()`.
+ *
+ * BUILD ORDERING NOTE: The OpenNext build runs BEFORE the detection pipeline
+ * because CDK synth needs the `.open-next/` directory to exist. This builder's
+ * `build()` method is called early in the deployment flow, not after detection.
+ * The plan's `buildCommand` is declarative — actual execution goes through
+ * `runOpenNextBuild()` which handles binary resolution, timeouts, and cleanup.
+ */
+import type { FrameworkBuilder } from "../../types/frameworkBuilder.js";
+/**
+ * OpenNext FrameworkBuilder for Next.js and Payload applications.
+ *
+ * Priority 10 — checked before Docker (priority 50) since OpenNext is more
+ * specific. Apps matching an OpenNext pattern use Lambda-based deployment
+ * with S3, DynamoDB, SQS, and CloudFront stacks.
+ */
+export declare const openNextBuilder: FrameworkBuilder;

package/dist/src/orchestration/builders/openNextBuilder.js

@@ -0,0 +1,144 @@
+/**
+ * OpenNextBuilder — FrameworkBuilder implementation for Next.js and Payload apps.
+ *
+ * Detects OpenNext patterns from infrastructure.ts, produces a build plan with
+ * the correct stack ordering, and delegates build execution to `runOpenNextBuild()`.
+ *
+ * BUILD ORDERING NOTE: The OpenNext build runs BEFORE the detection pipeline
+ * because CDK synth needs the `.open-next/` directory to exist. This builder's
+ * `build()` method is called early in the deployment flow, not after detection.
+ * The plan's `buildCommand` is declarative — actual execution goes through
+ * `runOpenNextBuild()` which handles binary resolution, timeouts, and cleanup.
+ */
+import { basename } from "path";
+import { success } from "@fjall/generator";
+import { logger } from "@fjall/util/logger";
+import { OPENNEXT_DEPLOY_ORDER, OPENNEXT_DESTROY_ORDER } from "../../types/operations.js";
+import { readInfrastructureContent } from "../../types/patternDetection.js";
+import { runOpenNextBuild, BUILD_TIMEOUT_MS, IMPORT_MAP_TIMEOUT_MS } from "../openNextBuild.js";
+/** Resource flags for all OpenNext apps (hasDatabase is dynamic) */
+function openNextResources(hasDatabase) {
+    return {
+        hasNetwork: true,
+        hasCompute: true,
+        hasDatabase,
+        hasStorage: true,
+        hasMessaging: true,
+        hasCdn: true
+    };
+}
+/**
+ * OpenNext FrameworkBuilder for Next.js and Payload applications.
+ *
+ * Priority 10 — checked before Docker (priority 50) since OpenNext is more
+ * specific. Apps matching an OpenNext pattern use Lambda-based deployment
+ * with S3, DynamoDB, SQS, and CloudFront stacks.
+ */
+export const openNextBuilder = {
+    name: "opennext",
+    priority: 10,
+    detect(context) {
+        const notDetected = {
+            detected: false,
+            pattern: null,
+            reason: "No OpenNext pattern found",
+            resources: openNextResources(false),
+            hasDatabase: false,
+            hasDockerfile: false
+        };
+        const content = readInfrastructureContent(context.appPath);
+        if (!content) {
+            return {
+                ...notDetected,
+                reason: "No infrastructure.ts found"
+            };
+        }
+        if (!content.includes("PatternFactory")) {
+            return {
+                ...notDetected,
+                reason: "No PatternFactory reference in infrastructure.ts"
+            };
+        }
+        if (content.includes('type: "payload"')) {
+            return {
+                detected: true,
+                pattern: "payload",
+                reason: 'PatternFactory with type: "payload" detected',
+                resources: openNextResources(true),
+                hasDatabase: true,
+                hasDockerfile: false
+            };
+        }
+        if (content.includes('type: "nextjs"')) {
+            // Next.js database detection is dynamic — check for explicit database usage
+            const hasDatabase = content.includes("DatabaseFactory.build(") ||
+                content.includes("database:");
+            return {
+                detected: true,
+                pattern: "nextjs",
+                reason: 'PatternFactory with type: "nextjs" detected',
+                resources: openNextResources(hasDatabase),
+                hasDatabase,
+                hasDockerfile: false
+            };
+        }
+        return {
+            ...notDetected,
+            reason: "PatternFactory found but no recognised pattern type"
+        };
+    },
+    plan(_context, detection) {
+        const preBuildCommands = detection.pattern === "payload"
+            ? [
+                {
+                    name: "payload-import-map",
+                    binary: "npx",
+                    args: ["payload", "generate:importmap"],
+                    timeoutMs: IMPORT_MAP_TIMEOUT_MS
+                }
+            ]
+            : [];
+        return {
+            builderName: "opennext",
+            deployOrder: OPENNEXT_DEPLOY_ORDER,
+            destroyOrder: OPENNEXT_DESTROY_ORDER,
+            parallelDestroy: true,
+            preBuildCommands,
+            buildCommand: {
+                name: "open-next-build",
+                binary: "open-next",
+                args: ["build"],
+                timeoutMs: BUILD_TIMEOUT_MS
+            },
+            requiresDockerBuild: false,
+            resources: detection.resources
+        };
+    },
+    async build(appPath, plan, callbacks, options) {
+        if (options?.skipBuild || options?.infraOnly) {
+            logger.debug("openNextBuilder", "Build skipped", {
+                skipBuild: options.skipBuild,
+                infraOnly: options.infraOnly
+            });
+            return success(undefined);
+        }
+        // Delegate to existing runOpenNextBuild which handles binary resolution,
+        // import map generation, timeouts, stream cleanup, and artefact validation.
+        // We build an ApplicationOperation and map BuildCallbacks to DeployCallbacks.
+        const operation = {
+            kind: "application",
+            appName: basename(appPath) || "app",
+            path: appPath
+        };
+        // Determine pattern from the plan's pre-build commands
+        const isPayload = plan.preBuildCommands.some((cmd) => cmd.name === "payload-import-map");
+        const pattern = isPayload ? "payload" : "nextjs";
+        const result = await runOpenNextBuild(operation, pattern, {
+            onOpenNextBuildStart: () => callbacks.onBuildStart?.("opennext"),
+            onOpenNextProgress: (message) => callbacks.onBuildProgress?.("opennext", message),
+            onOpenNextBuildComplete: () => callbacks.onBuildComplete?.("opennext"),
+            onOpenNextBuildError: (error) => callbacks.onBuildError?.("opennext", error)
+        });
+        return result;
+    }
+};

package/dist/src/orchestration/cascadeDestroyHelpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Multi-region destroy helpers for organisation cascade destruction.
+ *
+ * Mirrors the deployCascadeAccount() pattern from cascadeHelpers.ts but
+ * for destroy operations. No bootstrap step (unlike deploy).
+ */
+import type { DestroyParams } from "../types/params.js";
+import type { DeployCallbacks } from "../types/callbacks.js";
+import type { OrganisationOperation } from "../types/operations.js";
+import type { DeployServices } from "./serviceFactory.js";
+export interface CascadeDestroyAccountResult {
+    accountName: string;
+    accountId: string;
+    region: string;
+    success: boolean;
+    duration: number;
+    error?: string;
+    skipped?: boolean;
+}
+/**
+ * Destroy a single cascade account (platform or member) in a specific region.
+ *
+ * Flow: assume role -> synth -> CDK destroy -> failed-state cleanup if needed.
+ * No bootstrap step (unlike deploy).
+ */
+export declare function destroyCascadeAccount(params: DestroyParams, services: DeployServices, operation: OrganisationOperation, account: {
+    id: string;
+    name: string;
+    environment: string;
+}, deployType: "platform" | "account", region: string, callbacks: DeployCallbacks): Promise<CascadeDestroyAccountResult>;

package/dist/src/orchestration/cascadeDestroyHelpers.js

@@ -0,0 +1 @@
+import{logger as S}from"@fjall/util/logger";import{maskSensitiveOutput as c,getErrorMessage as A}from"@fjall/util";import{stubCallerIdentity as P}from"../types/deployment/index.js";import{CloudFormationClient as $,DescribeStacksCommand as R}from"@aws-sdk/client-cloudformation";import{NodeHttpHandler as O}from"@smithy/node-http-handler";import{ORGANISATION_TYPES as h,getOrganisationStackName as _}from"../types/operations.js";import{CdkContextBuilder as k}from"../services/supporting/CdkContextBuilder.js";import{buildParamsContext as F,assumeCascadeRole as x,forwardOutput as I}from"./contextHelpers.js";import{cleanupFailedStack as L}from"./stackCleanup.js";import{STACK_NOT_FOUND_PATTERN as K,STACK_FAILED_STATE_PATTERN as M}from"../types/constants.js";async function V(n,u,i,t,m,e,r){const o=Date.now(),a=`${t.name} (${e})`;r.onCascadeAccountStart?.(a,t.id,e,m);const f=await x(u.awsProvider,t.id,e,`fjall-cascade-destroy-${t.name}`);if(!f.success)return r.onCascadeAccountComplete?.(a,!1,c(f.error.message),e),{accountName:t.name,accountId:t.id,region:e,success:!1,duration:Date.now()-o,error:`AssumeRole failed: ${c(f.error.message)}`,skipped:!0};const{provider:v,credentials:l}=f.data,w=k.buildDeploymentContext({deployType:m,target:i.target,path:i.path,region:e,accountName:t.name,callerIdentity:P(t.id),...F({orgConfig:n.orgConfig,identity:n.identity})},{verbose:n.options?.verbose},n.orgConfig);r.onCascadeAccountPhaseChange?.(a,"synth",e);const y=await u.cdkService.runCdkSynth(w,I(r));if(!y.success){const s=c(`Synth failed: ${y.error}`);return r.onCascadeAccountComplete?.(a,!1,s,e),{accountName:t.name,accountId:t.id,region:e,success:!1,duration:Date.now()-o,error:s}}r.onCascadeAccountPhaseChange?.(a,"destroy",e);const d=_(m==="platform"?h.PLATFORM:h.ACCOUNT),D=await u.cdkService.runCdkDestroy(w,d,I(r),s=>r.onCascadeAccountResourceProgress?.(a,s,e),v,!0,l);if(!D.success){const s=D.error;if(s.includes(M)){S.warn("cascadeDestroy",`CDK destroy failed on ${d} in failed state, retrying via CloudFormation API`,{region:e,account:t.name});try{await L(d,e,l,void 0,r)}catch(C){const E=`cleanupFailedStack threw for ${d}: ${A(C)}`;S.warn("cascadeDestroy",E),r.onLog?.(E,"warn")}const p=await H(d,e,l);if(p.deleted)return r.onCascadeAccountComplete?.(a,!0,void 0,e),{accountName:t.name,accountId:t.id,region:e,success:!0,duration:Date.now()-o};if(p.error){const C=c(p.error);return r.onCascadeAccountComplete?.(a,!1,C,e),{accountName:t.name,accountId:t.id,region:e,success:!1,duration:Date.now()-o,error:C}}const T=c(`Stack ${d} cleanup attempted but stack still exists in ${e}`);return r.onCascadeAccountComplete?.(a,!1,T,e),{accountName:t.name,accountId:t.id,region:e,success:!1,duration:Date.now()-o,error:T}}const N=c(s);return r.onCascadeAccountComplete?.(a,!1,N,e),{accountName:t.name,accountId:t.id,region:e,success:!1,duration:Date.now()-o,error:N}}return r.onCascadeAccountComplete?.(a,!0,void 0,e),{accountName:t.name,accountId:t.id,region:e,success:!0,duration:Date.now()-o}}async function H(n,u,i){try{const e=(await new $({region:u,credentials:i,requestHandler:new O({requestTimeout:15e3})}).send(new R({StackName:n}))).Stacks?.[0]?.StackStatus;return!e||e==="DELETE_COMPLETE"?{deleted:!0}:{deleted:!1,error:`Stack still in ${e} after cleanup attempt`}}catch(t){return t instanceof Error&&t.message?.includes(K)?{deleted:!0}:(S.debug("cascadeDestroy","Stack verification failed",{error:A(t)}),{deleted:!1,error:`Stack verification failed: ${A(t)}`})}}export{V as destroyCascadeAccount};

package/dist/src/orchestration/cascadeHelpers.d.ts

@@ -0,0 +1,46 @@
+import { type Result } from "@fjall/generator";
+import type { DeployParams } from "../types/params.js";
+import type { DeployCallbacks } from "../types/callbacks.js";
+import type { OrganisationOperation } from "../types/operations.js";
+import type { DeployServices } from "./serviceFactory.js";
+import type { DomainDeployProvider } from "./domainInterface.js";
+import type { ProviderAccount } from "@fjall/util/config";
+/**
+ * Partition provider accounts into platform and member accounts.
+ * Used by both deploy and destroy orchestration.
+ */
+export declare function partitionAccounts(providerAccounts: ProviderAccount[]): {
+    platformAccount: ProviderAccount | undefined;
+    memberAccounts: ProviderAccount[];
+};
+export { buildCascadeRoleArn } from "./contextHelpers.js";
+/**
+ * Deploy a single cascade account (platform or member).
+ * Assumes the target account's role, sets env credentials, and deploys.
+ */
+export interface CascadeAccountResult {
+    outputs?: Record<string, string>;
+}
+export declare function deployCascadeAccount(params: DeployParams, services: DeployServices, operation: OrganisationOperation, account: {
+    id: string;
+    name: string;
+    environment: string;
+}, deployType: "platform" | "account", callbacks: DeployCallbacks, ipamPoolId?: string): Promise<Result<CascadeAccountResult>>;
+/**
+ * Read Platform stack outputs to extract IPAM pool IDs for member accounts.
+ * Output keys follow the pattern `IpamPoolId{12-digit-accountId}{regionSuffix}`.
+ * Returns a map keyed by `{accountId}-{regionSuffix}` → pool ID.
+ * Non-fatal: returns empty map on any error.
+ */
+export declare function readPlatformIpamPoolIds(services: DeployServices, platformAccount: {
+    id: string;
+    name: string;
+}, callbacks: DeployCallbacks): Promise<Map<string, string>>;
+/**
+ * Deploy configured domains: apex domains sequentially, then delegated
+ * domains in parallel. Delegates to the caller-provided DomainDeployProvider.
+ */
+export declare function deployDomains(provider: DomainDeployProvider, callbacks: DeployCallbacks): Promise<{
+    domainsDeployed: number;
+    errors: string[];
+}>;