import process from 'node:process';
import { AmplifyError, AmplifyFault, CDKContextKey, } from '@aws-amplify/platform-core';
import path from 'path';
import { MemoryContext, StackSelectionStrategy, } from '@aws-cdk/toolkit-lib';
import { tsImport } from 'tsx/esm/api';
import { CloudAssembly } from 'aws-cdk-lib/cx-api';
import { pathToFileURL } from 'url';
import { AssetStaging } from 'aws-cdk-lib/core';
import { Worker } from 'node:worker_threads';
/**
 * Invokes CDK command via execa
 */
export class CDKDeployer {
    cdkErrorMapper;
    backendLocator;
    packageManagerController;
    cdkToolkit;
    ioHost;
    absoluteCloudAssemblyLocation = path.resolve(process.cwd(), '.amplify/artifacts/cdk.out');
    /**
     * Instantiates instance of CDKDeployer
     */
    constructor(cdkErrorMapper, backendLocator, packageManagerController, cdkToolkit, ioHost) {
        this.cdkErrorMapper = cdkErrorMapper;
        this.backendLocator = backendLocator;
        this.packageManagerController = packageManagerController;
        this.cdkToolkit = cdkToolkit;
        this.ioHost = ioHost;
    }
    /**
     * Invokes cdk deploy API
     */
    deploy = async (backendId, deployProps) => {
        // Hack?? CDK uses global asset cache that is not cleared if assets are
        // changing within the same process (which now happens with CDK Toolkit APIs)
        // See https://github.com/aws/aws-cdk-cli/issues/236
        AssetStaging.clearAssetHashCache();
        const cx = await this.getCdkCloudAssembly(backendId, deployProps?.secretLastUpdated?.getTime());
        // Initiate synth for the cloud executable and send a message for display.
        const synthStartTime = Date.now();
        let synthAssembly, synthError = undefined;
        await this.ioHost.notify({
            message: `Backend synthesis started`,
            code: 'SYNTH_STARTED',
            action: 'amplify',
            time: new Date(),
            level: 'info',
            data: undefined,
        });
        try {
            synthAssembly = await this.cdkToolkit.synth(cx, {
                stacks: {
                    strategy: StackSelectionStrategy.ALL_STACKS,
                },
            });
        }
        catch (error) {
            synthError = error;
        }
        const synthTimeSeconds = Math.floor((Date.now() - synthStartTime) / 10) / 100;
        await this.ioHost.notify({
            message: `Backend synthesized in ${synthTimeSeconds} seconds`,
            code: 'SYNTH_FINISHED',
            action: 'amplify',
            time: new Date(),
            level: 'result',
            data: undefined,
        });
        // Typescript compilation. For type related errors, we prefer to show errors from TS to customers rather than synth
        const typeCheckStartTime = Date.now();
        await this.ioHost.notify({
            message: `Backend type checks started`,
            code: 'TS_STARTED',
            action: 'amplify',
            time: new Date(),
            level: 'info',
            data: undefined,
        });
        if (deployProps?.validateAppSources) {
            try {
                await this.compileProject(path.dirname(this.backendLocator.locate()));
            }
            catch (typeError) {
                if (synthError &&
                    AmplifyError.isAmplifyError(typeError) &&
                    typeError.name === 'FunctionEnvVarFileNotGeneratedError') {
                    // synth has failed and we don't have auto generated function environment definition files. This
                    // resulted in the exception caught here, which is not very useful for the customers.
                    // We instead throw the synth error for customers to fix what caused the synth to fail.
                    throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);
                }
                throw typeError;
            }
            finally {
                const typeCheckTimeSeconds = Math.floor((Date.now() - typeCheckStartTime) / 10) / 100;
                await this.ioHost.notify({
                    message: `Type checks completed in ${typeCheckTimeSeconds} seconds`,
                    code: 'TS_FINISHED',
                    action: 'amplify',
                    time: new Date(),
                    level: 'result',
                    data: undefined,
                });
            }
        }
        // If typescript compilation was successful but synth had failed, we throw synth error
        if (synthError) {
            throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);
        }
        // Perform actual deployment. CFN or hotswap
        const deployStartTime = Date.now();
        try {
            await this.cdkToolkit.deploy(synthAssembly, {
                stacks: {
                    strategy: StackSelectionStrategy.ALL_STACKS,
                },
                deploymentMethod: backendId.type === 'sandbox'
                    ? { method: 'hotswap', fallback: { method: 'direct' } }
                    : { method: 'direct' },
            });
        }
        catch (error) {
            await this.ioHost.notify({
                message: 'Deployment failed',
                code: 'DEPLOY_FAILED',
                action: 'amplify',
                time: new Date(),
                level: 'error',
                data: undefined,
            });
            throw this.cdkErrorMapper.getAmplifyError(error, backendId.type);
        }
        finally {
            await synthAssembly?.dispose();
        }
        return {
            deploymentTimes: {
                synthesisTime: synthTimeSeconds,
                totalTime: synthTimeSeconds +
                    Math.floor((Date.now() - deployStartTime) / 10) / 100,
            },
        };
    };
    /**
     * Invokes cdk destroy API
     */
    destroy = async (backendId) => {
        const deploymentStartTime = Date.now();
        try {
            await this.cdkToolkit.destroy(await this.getCdkCloudAssembly(backendId), {
                stacks: {
                    strategy: StackSelectionStrategy.ALL_STACKS,
                },
            });
            return {
                deploymentTimes: {
                    totalTime: Math.floor((Date.now() - deploymentStartTime) / 10) / 100,
                },
            };
        }
        catch (error) {
            throw this.cdkErrorMapper.getAmplifyError(error, backendId.type);
        }
    };
    compileProject = (projectDirectory) => {
        return new Promise((resolve, reject) => {
            const worker = new Worker(new URL('ts_compiler.js', import.meta.url), {
                workerData: { projectDirectory },
            });
            worker.on('message', () => {
                // do nothing
            });
            worker.on('error', reject);
            worker.on('exit', (code) => {
                if (code !== 0) {
                    reject(new AmplifyFault('TSCompilerWorkerFault', {
                        message: `Worker stopped with exit code ${code}`,
                    }));
                }
                resolve();
            });
        });
    };
    /**
     * Build cloud executable from dynamically importing the cdk ts file, i.e. backend.ts
     */
    getCdkCloudAssembly = (backendId, secretLastUpdated) => {
        const contextParams = {};
        if (backendId.type === 'sandbox') {
            if (secretLastUpdated) {
                contextParams['secretLastUpdated'] = secretLastUpdated;
            }
        }
        contextParams[CDKContextKey.BACKEND_NAMESPACE] = backendId.namespace;
        contextParams[CDKContextKey.BACKEND_NAME] = backendId.name;
        contextParams[CDKContextKey.DEPLOYMENT_TYPE] = backendId.type;
        return this.cdkToolkit.fromAssemblyBuilder(async () => {
            await tsImport(pathToFileURL(this.backendLocator.locate()).toString(), import.meta.url);
            /**
              By not having a child process with toolkit lib, the `process.on('beforeExit')` does not execute
              on the CDK side resulting in the app not getting synthesized properly. So we send a signal/message
              to the same process and catch it in backend package where App is initialized to explicitly perform synth
             */
            process.emit('message', 'amplifySynth', undefined);
            return new CloudAssembly(this.absoluteCloudAssemblyLocation);
        }, {
            contextStore: new MemoryContext(contextParams),
            outdir: this.absoluteCloudAssemblyLocation,
        });
    };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk_deployer.js","sourceRoot":"","sources":["../src/cdk_deployer.ts"],"names":[],"mappings":"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","sourcesContent":["import process from 'node:process';\n\nimport {\n  BackendDeployer,\n  DeployProps,\n} from './cdk_deployer_singleton_factory.js';\nimport { CdkErrorMapper } from './cdk_error_mapper.js';\nimport {\n  AmplifyIOHost,\n  BackendIdentifier,\n  type PackageManagerController,\n} from '@aws-amplify/plugin-types';\nimport {\n  AmplifyError,\n  AmplifyFault,\n  BackendLocator,\n  CDKContextKey,\n} from '@aws-amplify/platform-core';\nimport path from 'path';\nimport {\n  MemoryContext,\n  StackSelectionStrategy,\n  Toolkit,\n} from '@aws-cdk/toolkit-lib';\nimport { tsImport } from 'tsx/esm/api';\nimport { CloudAssembly } from 'aws-cdk-lib/cx-api';\nimport { pathToFileURL } from 'url';\nimport { AssetStaging } from 'aws-cdk-lib/core';\nimport { Worker } from 'node:worker_threads';\n\n/**\n * Invokes CDK command via execa\n */\nexport class CDKDeployer implements BackendDeployer {\n  private readonly absoluteCloudAssemblyLocation = path.resolve(\n    process.cwd(),\n    '.amplify/artifacts/cdk.out',\n  );\n\n  /**\n   * Instantiates instance of CDKDeployer\n   */\n  constructor(\n    private readonly cdkErrorMapper: CdkErrorMapper,\n    private readonly backendLocator: BackendLocator,\n    private readonly packageManagerController: PackageManagerController,\n    private readonly cdkToolkit: Toolkit,\n    private readonly ioHost: AmplifyIOHost,\n  ) {}\n\n  /**\n   * Invokes cdk deploy API\n   */\n  deploy = async (backendId: BackendIdentifier, deployProps?: DeployProps) => {\n    // Hack?? CDK uses global asset cache that is not cleared if assets are\n    // changing within the same process (which now happens with CDK Toolkit APIs)\n    // See https://github.com/aws/aws-cdk-cli/issues/236\n    AssetStaging.clearAssetHashCache();\n\n    const cx = await this.getCdkCloudAssembly(\n      backendId,\n      deployProps?.secretLastUpdated?.getTime(),\n    );\n    // Initiate synth for the cloud executable and send a message for display.\n    const synthStartTime = Date.now();\n    let synthAssembly,\n      synthError: Error | undefined = undefined;\n    await this.ioHost.notify({\n      message: `Backend synthesis started`,\n      code: 'SYNTH_STARTED',\n      action: 'amplify',\n      time: new Date(),\n      level: 'info',\n      data: undefined,\n    });\n\n    try {\n      synthAssembly = await this.cdkToolkit.synth(cx, {\n        stacks: {\n          strategy: StackSelectionStrategy.ALL_STACKS,\n        },\n      });\n    } catch (error) {\n      synthError = error as Error;\n    }\n\n    const synthTimeSeconds =\n      Math.floor((Date.now() - synthStartTime) / 10) / 100;\n\n    await this.ioHost.notify({\n      message: `Backend synthesized in ${synthTimeSeconds} seconds`,\n      code: 'SYNTH_FINISHED',\n      action: 'amplify',\n      time: new Date(),\n      level: 'result',\n      data: undefined,\n    });\n\n    // Typescript compilation. For type related errors, we prefer to show errors from TS to customers rather than synth\n    const typeCheckStartTime = Date.now();\n    await this.ioHost.notify({\n      message: `Backend type checks started`,\n      code: 'TS_STARTED',\n      action: 'amplify',\n      time: new Date(),\n      level: 'info',\n      data: undefined,\n    });\n\n    if (deployProps?.validateAppSources) {\n      try {\n        await this.compileProject(path.dirname(this.backendLocator.locate()));\n      } catch (typeError) {\n        if (\n          synthError &&\n          AmplifyError.isAmplifyError(typeError) &&\n          typeError.name === 'FunctionEnvVarFileNotGeneratedError'\n        ) {\n          // synth has failed and we don't have auto generated function environment definition files. This\n          // resulted in the exception caught here, which is not very useful for the customers.\n          // We instead throw the synth error for customers to fix what caused the synth to fail.\n          throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);\n        }\n        throw typeError;\n      } finally {\n        const typeCheckTimeSeconds =\n          Math.floor((Date.now() - typeCheckStartTime) / 10) / 100;\n        await this.ioHost.notify({\n          message: `Type checks completed in ${typeCheckTimeSeconds} seconds`,\n          code: 'TS_FINISHED',\n          action: 'amplify',\n          time: new Date(),\n          level: 'result',\n          data: undefined,\n        });\n      }\n    }\n\n    // If typescript compilation was successful but synth had failed, we throw synth error\n    if (synthError) {\n      throw this.cdkErrorMapper.getAmplifyError(synthError, backendId.type);\n    }\n\n    // Perform actual deployment. CFN or hotswap\n    const deployStartTime = Date.now();\n    try {\n      await this.cdkToolkit.deploy(synthAssembly!, {\n        stacks: {\n          strategy: StackSelectionStrategy.ALL_STACKS,\n        },\n        deploymentMethod:\n          backendId.type === 'sandbox'\n            ? { method: 'hotswap', fallback: { method: 'direct' } }\n            : { method: 'direct' },\n      });\n    } catch (error) {\n      await this.ioHost.notify({\n        message: 'Deployment failed',\n        code: 'DEPLOY_FAILED',\n        action: 'amplify',\n        time: new Date(),\n        level: 'error',\n        data: undefined,\n      });\n      throw this.cdkErrorMapper.getAmplifyError(error as Error, backendId.type);\n    } finally {\n      await synthAssembly?.dispose();\n    }\n\n    return {\n      deploymentTimes: {\n        synthesisTime: synthTimeSeconds,\n        totalTime:\n          synthTimeSeconds +\n          Math.floor((Date.now() - deployStartTime) / 10) / 100,\n      },\n    };\n  };\n\n  /**\n   * Invokes cdk destroy API\n   */\n  destroy = async (backendId: BackendIdentifier) => {\n    const deploymentStartTime = Date.now();\n    try {\n      await this.cdkToolkit.destroy(await this.getCdkCloudAssembly(backendId), {\n        stacks: {\n          strategy: StackSelectionStrategy.ALL_STACKS,\n        },\n      });\n      return {\n        deploymentTimes: {\n          totalTime: Math.floor((Date.now() - deploymentStartTime) / 10) / 100,\n        },\n      };\n    } catch (error) {\n      throw this.cdkErrorMapper.getAmplifyError(error as Error, backendId.type);\n    }\n  };\n\n  compileProject = (projectDirectory: string): Promise<void> => {\n    return new Promise((resolve, reject) => {\n      const worker = new Worker(new URL('ts_compiler.js', import.meta.url), {\n        workerData: { projectDirectory },\n      });\n      worker.on('message', () => {\n        // do nothing\n      });\n      worker.on('error', reject);\n      worker.on('exit', (code) => {\n        if (code !== 0) {\n          reject(\n            new AmplifyFault('TSCompilerWorkerFault', {\n              message: `Worker stopped with exit code ${code}`,\n            }),\n          );\n        }\n        resolve();\n      });\n    });\n  };\n\n  /**\n   * Build cloud executable from dynamically importing the cdk ts file, i.e. backend.ts\n   */\n  private getCdkCloudAssembly = (\n    backendId: BackendIdentifier,\n    secretLastUpdated?: number,\n  ) => {\n    const contextParams: {\n      [key: string]: unknown;\n    } = {};\n\n    if (backendId.type === 'sandbox') {\n      if (secretLastUpdated) {\n        contextParams['secretLastUpdated'] = secretLastUpdated;\n      }\n    }\n\n    contextParams[CDKContextKey.BACKEND_NAMESPACE] = backendId.namespace;\n    contextParams[CDKContextKey.BACKEND_NAME] = backendId.name;\n    contextParams[CDKContextKey.DEPLOYMENT_TYPE] = backendId.type;\n    return this.cdkToolkit.fromAssemblyBuilder(\n      async () => {\n        await tsImport(\n          pathToFileURL(this.backendLocator.locate()).toString(),\n          import.meta.url,\n        );\n\n        /**\n          By not having a child process with toolkit lib, the `process.on('beforeExit')` does not execute\n          on the CDK side resulting in the app not getting synthesized properly. So we send a signal/message\n          to the same process and catch it in backend package where App is initialized to explicitly perform synth\n         */\n        process.emit('message', 'amplifySynth', undefined);\n        return new CloudAssembly(this.absoluteCloudAssemblyLocation);\n      },\n      {\n        contextStore: new MemoryContext(contextParams),\n        outdir: this.absoluteCloudAssemblyLocation,\n      },\n    );\n  };\n}\n"]}