"use strict";

const zlib = require("zlib");

const path = require("path");

const util = require("util");

const AWS = require("aws-sdk");

const fs = require("fs-extra");

const chalk = require("chalk");

const WebSocket = require("ws");

const esbuild = require("esbuild");

const spawn = require("cross-spawn");

const {

logger,

getChildLogger,

STACK_DEPLOY_STATUS,

Runtime,

} = require("@serverless-stack/core");

const s3 = new AWS.S3();

const paths = require("./util/paths");

const {

sleep,

synth,

deploy,

loadCache,

updateCache,

isGoRuntime,

isNodeRuntime,

isDotnetRuntime,

isPythonRuntime,

prepareCdk,

writeConfig,

getTsBinPath,

checkFileExists,

getEsbuildTarget,

writeOutputsFile,

printDeployResults,

generateStackChecksums,

loadEsbuildConfigOverrides,

reTranspile: reTranpileCdk,

} = require("./util/cdkHelpers");

const array = require("../lib/array");

const Watcher = require("./util/Watcher");

const objectUtil = require("../lib/object");

const CdkWatcherState = require("./util/CdkWatcherState");

const LambdaWatcherState = require("./util/LambdaWatcherState");

const { serializeError, deserializeError } = require("../lib/serializeError");

// Setup logger

const wsLogger = getChildLogger("websocket");

const clientLogger = getChildLogger("client");

const WEBSOCKET_CLOSE_CODE = {

NEW_CLIENT_CONNECTED: 4901,

};

const MOCK_SLOW_ESBUILD_RETRANSPILE_IN_MS = 0;

let watcher;

let cdkWatcherState;

let lambdaWatcherState;

let esbuildService;

let server;

let debugEndpoint;

let debugBucketArn;

let debugBucketName;

// This flag is currently used by the "sst.Script" construct to make the "BuiltAt"

// remain the same when rebuilding infrastructure.

const debugStartedAt = Date.now();

const clientState = {

ws: null,

wsKeepAliveTimer: null,

};

const IS_TEST = process.env.__TEST__ === "true";

module.exports = async function (argv, config, cliInfo) {

const { inputFiles: cdkInputFiles } = await prepareCdk(argv, cliInfo, config);

// Load cache

const cacheData = loadCache();

// Deploy debug stack

const debugStackOutputs = await deployDebugStack(

argv,

config,

cliInfo,

cacheData

);

debugEndpoint = debugStackOutputs.Endpoint;

debugBucketArn = debugStackOutputs.BucketArn;

debugBucketName = debugStackOutputs.BucketName;

// Add input listener

addInputListener();

// Deploy app

const appStackDeployRet = await deployApp(argv, config, cliInfo, cacheData);

const lambdaHandlers = await getDeployedLambdaHandlers();

await updateStaticSiteEnvironmentOutputs(appStackDeployRet);

logger.info("");

logger.info("==========================");

logger.info(" Starting Live Lambda Dev");

logger.info("==========================");

logger.info("");

cdkWatcherState = new CdkWatcherState({

inputFiles: cdkInputFiles,

checksumData: cacheData.appStacks.checksumData,

onReBuild: handleCdkReBuild,

onLint: (inputFiles) => handleCdkLint(inputFiles, config),

onTypeCheck: (inputFiles) => handleCdkTypeCheck(inputFiles, config),

onSynth: () => handleCdkSynth(cliInfo),

onReDeploy: ({ checksumData }) =>

handleCdkReDeploy(cliInfo, cacheData, checksumData),

onAddWatchedFiles: handleAddWatchedFiles,

onRemoveWatchedFiles: handleRemoveWatchedFiles,

});

lambdaWatcherState = new LambdaWatcherState({

lambdaHandlers,

onTranspileNode: (entrypointData) =>

handleTranspileNode(entrypointData, config),

onRunLint: (srcPath, inputFiles) =>

handleRunLint(srcPath, inputFiles, config),

onRunTypeCheck: (srcPath, inputFiles, tsconfig) =>

handleRunTypeCheck(srcPath, inputFiles, tsconfig, config),

onCompileGo: handleCompileGo,

onBuildDotnet: handleBuildDotnet,

onBuildPython: handleBuildPython,

onAddWatchedFiles: handleAddWatchedFiles,

onRemoveWatchedFiles: handleRemoveWatchedFiles,

});

await lambdaWatcherState.runInitialBuild(IS_TEST);

// Save Lambda watcher state to file

if (IS_TEST) {

const testOutputPath = path.join(

paths.appPath,

paths.appBuildDir,

"test-output.json"

);

fs.writeFileSync(

testOutputPath,

JSON.stringify(lambdaWatcherState.getState())

);

process.exit(0);

return;

}

// Start code watcher, Lambda runtime server, and websocket client

await startWatcher();

await startRuntimeServer(argv.port);

startWebSocketClient();

};

async function deployDebugStack(argv, config, cliInfo, cacheData) {

// Do not deploy if running test

if (IS_TEST) {

return {

Endpoint: "ws://test-endpoint",

BucketArn: "bucket-arn",

BucketName: "bucket-name",

};

}

logger.info("");

logger.info("=======================");

logger.info(" Deploying debug stack");

logger.info("=======================");

logger.info("");

const stackName = `${config.stage}-${config.name}-debug-stack`;

const appBuildLibPath = path.join(paths.appBuildPath, "lib");

const cdkOptions = {

...cliInfo.cdkOptions,

app: `node bin/index.js ${stackName} ${config.stage} ${config.region} ${paths.appPath} ${appBuildLibPath}`,

output: "cdk.out",

};

// Change working directory

// Note: When deploying the debug stack, the current working directory is user's app.

// Setting the current working directory to debug stack cdk app directory to allow

// Lambda Function construct be able to reference code with relative path.

process.chdir(path.join(paths.ownPath, "assets", "debug-stack"));

// Build

const cdkManifest = await synth(cdkOptions);

const cdkOutPath = path.join(

paths.ownPath,

"assets",

"debug-stack",

"cdk.out"

);

const checksumData = generateStackChecksums(cdkManifest, cdkOutPath);

// Deploy

const isCacheChanged = checkCacheChanged(cacheData.debugStack, checksumData);

const deployRet = isCacheChanged

? await deploy(cdkOptions)

: cacheData.debugStack.deployRet;

logger.debug("deployRet", deployRet);

// Restore working directory

process.chdir(paths.appPath);

// Get WebSocket endpoint

if (

!deployRet ||

deployRet.length !== 1 ||

deployRet[0].status === STACK_DEPLOY_STATUS.FAILED

) {

throw new Error(`Failed to deploy debug stack ${stackName}`);

} else if (!deployRet[0].outputs || !deployRet[0].outputs.Endpoint) {

throw new Error(

`Failed to get the endpoint from the deployed debug stack ${stackName}`

);

}

// Cache changed => Update cache

if (isCacheChanged) {

cacheData.debugStack = { checksumData, deployRet };

updateCache(cacheData);

}

// Cache NOT changed => Print stack results since deploy was skipped

else {

await printMockedDeployResults(deployRet);

}

return deployRet[0].outputs;

}

async function deployApp(argv, config, cliInfo, cacheData) {

logger.info("");

logger.info("===============");

logger.info(" Deploying app");

logger.info("===============");

logger.info("");

await writeConfig({

...config,

debugEndpoint,

debugBucketArn,

debugBucketName,

debugStartedAt,

debugIncreaseTimeout: argv.increaseTimeout || false,

});

// Build

const cdkManifest = await synth(cliInfo.cdkOptions);

const cdkOutPath = path.join(paths.appBuildPath, "cdk.out");

const checksumData = generateStackChecksums(cdkManifest, cdkOutPath);

let deployRet;

if (IS_TEST) {

deployRet = [];

cacheData.appStacks = { checksumData, deployRet };

} else {

// Deploy

const isCacheChanged = checkCacheChanged(cacheData.appStacks, checksumData);

deployRet = isCacheChanged

? await deploy(cliInfo.cdkOptions)

: cacheData.appStacks.deployRet;

// Check all stacks deployed successfully

if (

deployRet.some((stack) => stack.status === STACK_DEPLOY_STATUS.FAILED)

) {

throw new Error(`Failed to deploy the app`);

}

// Cache changed => Update cache

if (isCacheChanged) {

cacheData.appStacks = { checksumData, deployRet };

updateCache(cacheData);

}

// Cache NOT changed => Print stack results since deploy was skipped

else {

// print a empty line before printing deploy results

logger.info("");

await printMockedDeployResults(deployRet);

}

}

// Write outputsFile

if (argv.outputsFile) {

await writeOutputsFile(

deployRet,

path.join(paths.appPath, argv.outputsFile)

);

}

return deployRet;

}

async function startWatcher() {

// Watcher will build all the Lambda handlers on start and rebuild on code change

watcher = new Watcher({

cdkFiles: cdkWatcherState.getWatchedFiles(),

lambdaFiles: lambdaWatcherState.getWatchedFiles(),

onFileChange: (file) => {

cdkWatcherState.handleFileChange(file);

lambdaWatcherState.handleFileChange(file);

},

});

}

async function startRuntimeServer(port) {

// note: 0.0.0.0 does not work on Windows

server = new Runtime.Server({

port: port + 1,

});

server.listen();

}

function addInputListener() {

if (IS_TEST) {

return;

}

process.stdin.on("data", () => {

cdkWatcherState && cdkWatcherState.handleInput();

});

process.on("SIGINT", function () {

console.log(

chalk.yellow(

"\nStopping Live Lambda Dev, run `sst deploy` to deploy the latest changes."

)

);

process.exit(0);

});

// Note: the "readline" way of listening for each keystroke did not play well

// with the "prompts" modules, as the "prompts" module closes the rl

// interface. For now, we will listen for the SIGINT event above.

//const rl = readline.createInterface({

// input: process.stdin,

// output: process.stdout

//});

//process.stdin.on('keypress', async (c, k) => {

// //console.log("keypress", JSON.stringify({ c, k }));

// if (!k) { return; }

// // CTRL+c or CTRL+d

// if ((k.name === "c" || k.name === "d") && k.ctrl === true) {

// console.log(chalk.yellow("\nStopping Live Lambda Dev, run `sst deploy` to deploy the latest changes.\n"));

// process.exit(0);

// }

// else if (k.name === "enter") {

// cdkWatcherState && cdkWatcherState.handleInput();

// }

//});

}

////////////////////////////

// CDK Reloader functions //

////////////////////////////

async function handleCdkReBuild() {

try {

const inputFiles = await reTranpileCdk();

cdkWatcherState.handleReBuildSucceeded({ inputFiles });

} catch (e) {

cdkWatcherState.handleReBuildFailed(e);

}

}

function handleCdkLint(inputFiles, config) {

// Validate lint enabled

if (!config.lint) {

return null;

}

inputFiles = inputFiles.filter(

(file) =>

file.indexOf("node_modules") === -1 &&

(file.endsWith(".ts") || file.endsWith(".js"))

);

// Validate inputFiles

if (inputFiles.length === 0) {

return null;

}

const cp = spawn(

"node",

[

path.join(paths.appBuildPath, "eslint.js"),

process.env.NO_COLOR === "true" ? "--no-color" : "--color",

...inputFiles,

],

{ stdio: "inherit", cwd: paths.ownPath }

);

cp.on("close", (code) => {

cdkWatcherState.handleLintDone({ cp, code });

});

return cp;

}

function handleCdkTypeCheck(inputFiles, config) {

// Validate typeCheck enabled

if (!config.typeCheck) {

return null;

}

const tsFiles = inputFiles.filter((file) => file.endsWith(".ts"));

// Validate tsFiles

if (tsFiles.length === 0) {

return null;

}

const cp = spawn(

getTsBinPath(),

[

"--noEmit",

"--pretty",

process.env.NO_COLOR === "true" ? "false" : "true",

],

{

stdio: "inherit",

cwd: paths.appPath,

}

);

cp.on("close", (code) => {

cdkWatcherState.handleTypeCheckDone({ cp, code });

});

return cp;

}

function handleCdkSynth(cliInfo) {

const synthPromise = synth(cliInfo.cdkOptions);

synthPromise

.then((cdkManifest) => {

const cdkOutPath = path.join(paths.appBuildPath, "cdk.out");

const checksumData = generateStackChecksums(cdkManifest, cdkOutPath);

cdkWatcherState.handleSynthDone({ hasError: false, checksumData });

})

.catch((e) => {

cdkWatcherState.handleSynthDone({

hasError: true,

isCancelled: e.cancelled,

});

});

return synthPromise;

}

async function handleCdkReDeploy(cliInfo, cacheData, checksumData) {

try {

// While deploying, synth might run again if another change is made. That

// can cause the value of 'lastSynthedChecksumData' to change. So we need

// to clone the value.

checksumData = { ...checksumData };

const deployRet = await deploy(cliInfo.cdkOptions);

if (

deployRet.some((stack) => stack.status === STACK_DEPLOY_STATUS.FAILED)

) {

// Throw a dummy error. Watcher just need to catch something and prints

// out that redeploy failed. Do not need to throw with an error message

// b/c deploy status is printed out onto the terminal.

throw null;

}

// Update Lambda state

const lambdaHandlers = await getDeployedLambdaHandlers();

lambdaWatcherState.handleUpdateLambdaHandlers(lambdaHandlers);

// Update StaticSite environment outputs

await updateStaticSiteEnvironmentOutputs(deployRet);

// Update cache

cacheData.appStacks = { checksumData, deployRet };

updateCache(cacheData);

cdkWatcherState.handleReDeployDone({ hasError: false });

} catch (e) {

cdkWatcherState.handleReDeployDone({ hasError: true });

}

}

function handleAddWatchedFiles(files) {

if (files.length > 0) {

watcher.addFiles(files);

}

}

async function handleRemoveWatchedFiles(files) {

if (files.length > 0) {

await watcher.removeFiles(files);

}

}

////////////////////////////////////////

// Lambda Reloader functions - NodeJS //

////////////////////////////////////////

async function handleTranspileNode(

{ srcPath, handler, bundle, esbuilder, onSuccess, onFailure },

config

) {

// Sample input:

// srcPath 'service'

// handler 'src/lambda.handler'

//

// Sample output path:

// metafile 'services/user-service/.build/.esbuild.service-src-lambda-hander.json'

// fullPath 'services/user-service/src/lambda.js'

// outSrcPath 'services/user-service/.build/src'

//

// Transpiled .js and .js.map are output in .build folder with original handler structure path

try {

const metafile = getEsbuildMetafilePath(paths.appPath, srcPath, handler);

const fullPath = await getHandlerFilePath(paths.appPath, srcPath, handler);

const outSrcPath = path.join(

srcPath,

paths.appBuildDir,

path.dirname(handler)

);

const handlerParts = path.basename(handler).split(".");

const outHandler = handlerParts.pop();

const outEntry = `${handlerParts.join(".")}.js`;

// Get tsconfig

const tsconfigPath = path.join(paths.appPath, srcPath, "tsconfig.json");

const isTs = await checkFileExists(tsconfigPath);

const tsconfig = isTs ? tsconfigPath : undefined;

// Transpile

esbuilder = esbuilder

? await runReTranspileNode(esbuilder)

: await runTranspileNode(

config,

srcPath,

handler,

bundle,

metafile,

tsconfig,

fullPath,

outSrcPath

);

if (server)

server.drain({

srcPath: path.join(srcPath, handler),

outPath: outSrcPath,

});

onSuccess({

tsconfig,

esbuilder,

outEntryPoint: {

entry: outEntry,

handler: outHandler,

srcPath: outSrcPath,

origHandlerFullPosixPath: getHandlerFullPosixPath(srcPath, handler),

},

inputFiles: await getInputFilesFromEsbuildMetafile(metafile),

});

} catch (e) {

logger.debug("handleTranspileNode error", e);

onFailure(e);

}

}

async function runTranspileNode(

config,

srcPath,

handler,

bundle,

metafile,

tsconfig,

fullPath,

outSrcPath

) {

logger.debug(`Transpiling ${handler}...`);

// Start esbuild service is has not started

if (!esbuildService) {

esbuildService = esbuild;

}

// Get custom esbuild config

const customConfig = await loadEsbuildConfigOverrides(

config.esbuildConfig || bundle.esbuildConfig

);

const result = await esbuildService.build({

external: await getEsbuildExternal(srcPath),

loader: getEsbuildLoader(bundle),

metafile: true,

tsconfig,

bundle: true,

format: "cjs",

sourcemap: true,

platform: "node",

incremental: true,

entryPoints: [fullPath],

target: [getEsbuildTarget()],

color: process.env.NO_COLOR !== "true",

outdir: path.join(paths.appPath, outSrcPath),

logLevel: process.env.DEBUG ? "warning" : "error",

...customConfig,

});

require("fs").writeFileSync(metafile, JSON.stringify(result.metafile));

return result;

}

async function runReTranspileNode(esbuilder) {

await esbuilder.rebuild();

// Mock esbuild taking long to rebuild

if (MOCK_SLOW_ESBUILD_RETRANSPILE_IN_MS) {

logger.debug(

`Mock rebuild wait (${MOCK_SLOW_ESBUILD_RETRANSPILE_IN_MS}ms)...`

);

await sleep(MOCK_SLOW_ESBUILD_RETRANSPILE_IN_MS);

logger.debug(`Mock rebuild wait done`);

}

return esbuilder;

}

function handleRunLint(srcPath, inputFiles, config) {

// Validate lint enabled

// note: invoke LambdaWatcherState.handleLintDone() even if it's not run. B/c

// if both Lint and TypeCheck are disabled, neither handleLintDone() or

// handleTypeCheckDone() will be called. And in turn updateState() will

// not be called in LambdaWatcherState. This will lead to the state stuck

// in the "Rebuilding code..." state.

// Hence, call handleLintDone() in a setTimeout to mimic the lint

// process has completed.

if (!config.lint) {

setTimeout(() => lambdaWatcherState.handleLintDone(srcPath), 0);

return null;

}

inputFiles = inputFiles.filter(

(file) =>

file.indexOf("node_modules") === -1 &&

(file.endsWith(".ts") || file.endsWith(".js"))

);

// Validate inputFiles

if (inputFiles.length === 0) {

setTimeout(() => lambdaWatcherState.handleLintDone(srcPath), 0);

return null;

}

const cp = spawn(

"node",

[

path.join(paths.appBuildPath, "eslint.js"),

process.env.NO_COLOR === "true" ? "--no-color" : "--color",

...inputFiles,

],

{ stdio: "inherit", cwd: paths.ownPath }

);

cp.on("close", (code) => {

logger.debug(`linter exited with code ${code}`);

lambdaWatcherState.handleLintDone(srcPath);

});

return cp;

}

function handleRunTypeCheck(srcPath, inputFiles, tsconfig, config) {

// Validate typeCheck enabled

// note: invoke LambdaWatcherState.handleTypeCheckDone() even if it's not run. B/c

// if both Lint and TypeCheck are disabled, neither handleLintDone() or

// handleTypeCheckDone() will be called. And in turn updateState() will

// not be called in LambdaWatcherState. This will lead to the state stuck

// in the "Rebuilding code..." state.

// Hence, call handleTypeCheckDone() in a setTimeout to mimic the type check

// process has completed.

if (!config.typeCheck) {

setTimeout(() => lambdaWatcherState.handleTypeCheckDone(srcPath), 0);

return null;

}

const tsFiles = inputFiles.filter((file) => file.endsWith(".ts"));

// Validate tsFiles

if (tsFiles.length === 0) {

setTimeout(() => lambdaWatcherState.handleTypeCheckDone(srcPath), 0);

return null;

}

if (tsconfig === undefined) {

logger.error(

`Cannot find a "tsconfig.json" in the function's srcPath: ${path.resolve(

srcPath

)}`

);

setTimeout(() => lambdaWatcherState.handleTypeCheckDone(srcPath), 0);

return null;

}

const cp = spawn(

getTsBinPath(),

[

"--noEmit",

"--pretty",

process.env.NO_COLOR === "true" ? "false" : "true",

],

{

stdio: "inherit",

cwd: path.join(paths.appPath, srcPath),

}

);

cp.on("close", (code) => {

logger.debug(`type checker exited with code ${code}`);

lambdaWatcherState.handleTypeCheckDone(srcPath);

});

return cp;

}

async function getHandlerFilePath(appPath, srcPath, handler) {

// Check entry path exists

let entryPath;

const entryPathExists = [".ts", ".tsx", ".js", ".jsx"].some((ext) => {

entryPath = path.join(

appPath,

srcPath,

addExtensionToHandler(handler, ext)

);

return fs.existsSync(entryPath);

});

// Print out the error message and throw

if (!entryPathExists) {

const handlerPosixPath = getHandlerFullPosixPath(srcPath, handler);

const errorMessage = `Cannot find a handler file for "${handlerPosixPath}"`;

logger.error(`${chalk.red("error")} ${errorMessage}\n`);

throw new Error(errorMessage);

}

return entryPath;

}

async function getEsbuildExternal(srcPath) {

let externals;

try {

const packageJson = await fs.readJson(path.join(srcPath, "package.json"));

externals = Object.keys({

...(packageJson.dependencies || {}),

...(packageJson.devDependencies || {}),

...(packageJson.peerDependencies || {}),

});

} catch (e) {

logger.warn(`No package.json found in ${srcPath}`);

externals = [];

}

// Always include "aws-sdk" in externals

// Note: this helps with the case where "aws-sdk" is not listed in the srcPath's

// package.json. It could be in parent directories' package.json.

//

// Example 1: the SST app is a package inside a yarn workspace, and

// "aws-sdk" is in repo root's package.json.

// Example 2: the SST app is at the repo root, but the Lambda function has

// a srcPath. And "aws-sdk" is in repo root's package.json.

//

// The long term fix is to run `esbuild` and if the input files contain

// "node_modules/XYZ", kill the esbuild service. And remember "XYZ". And

// the next time the function gets invoked, start a new esbuild process,

// and set "XYZ" as an external. Need to check other packages in the Yarn

// workspace do not show up as "node_modules" in the input files. Because

// we want them to be included in input files and watch them.

if (!externals.includes("aws-sdk")) {

externals.push("aws-sdk");

}

return externals;

}

function getEsbuildLoader(bundle) {

if (bundle) {

return bundle.loader || {};

}

return undefined;

}

function getEsbuildMetafilePath(appPath, srcPath, handler) {

const key = `${srcPath}/${handler}`.replace(/[/.]/g, "-");

const outSrcFullPath = path.join(appPath, srcPath, paths.appBuildDir);

return path.join(outSrcFullPath, `.esbuild.${key}.json`);

}

async function getInputFilesFromEsbuildMetafile(file) {

let metaJson;

try {

metaJson = await fs.readJson(file);

} catch (e) {

logger.error("There was a problem reading the build metafile", e);

}

return Object.keys(metaJson.inputs).map((input) => path.resolve(input));

}

////////////////////////////////////

// Lambda Reloader functions - Go //

////////////////////////////////////

async function handleCompileGo({ srcPath, handler, onSuccess, onFailure }) {

try {

const { outEntry } = await runCompile(srcPath, handler);

onSuccess({

outEntryPoint: {

entry: outEntry,

origHandlerFullPosixPath: getHandlerFullPosixPath(srcPath, handler),

},

inputFiles: [],

});

} catch (e) {

logger.debug("handleCompileGo error", e);

onFailure(e);

}

}

function runCompile(srcPath, handler) {

// Sample input:

// srcPath 'services/user-service'

// handler 'src/lambda.go'

//

// Sample output path:

// absHandlerPath 'services/user-service/src/lambda.go'

// relBinPath -> if handler is 'src/lambda.go' => '.build/src/lambda'

// -> if handler is 'src' => '.build/src/main'

// binPath 'services/user-service/.build/src/lambda'

//

// Transpiled Go executables are output in .build folder with original handler structure path

const absSrcPath = path.join(paths.appPath, srcPath);

const absHandlerPath = path.join(paths.appPath, srcPath, handler);

let relBinPath;

if (handler.endsWith(".go")) {

relBinPath = path.join(

paths.appBuildDir,

path.dirname(handler),

path.basename(handler).slice(0, -3)

);

} else {

relBinPath = path.join(paths.appBuildDir, handler, "main");

}

// Append ".exe" for Windows

if (process.platform === "win32") {

relBinPath = `${relBinPath}.exe`;

}

logger.debug(`Building ${absHandlerPath}...`);

return new Promise((resolve, reject) => {

const cp = spawn(

"go",

[

"build",

"-ldflags",

"-s -w",

"-o",

relBinPath,

// specify absolute path b/c if "handler" can be a folder, and a relative path does not work

absHandlerPath,

],

{

stdio: "inherit",

env: {

...process.env,

// Compile for local runtime b/c the go executable will be run locally

//GOOS: "linux",

},

cwd: absSrcPath,

}

);

cp.on("error", (e) => {

logger.debug("go build error", e);

});

cp.on("close", (code) => {

logger.debug(`go build exited with code ${code}`);

if (code !== 0) {

reject(

new Error(

`There was an problem compiling the handler at "${absHandlerPath}".`

)

);

} else {

resolve({

outEntry: path.join(absSrcPath, relBinPath),

});

}

});

});

}

//////////////////////////////////////

// Lambda Reloader functions - .NET //

//////////////////////////////////////

async function handleBuildDotnet({ srcPath, handler, onSuccess, onFailure }) {

try {

const { outEntry } = await runBuildDotnet(srcPath, handler);

onSuccess({

outEntryPoint: {

entry: outEntry,

handler,

origHandlerFullPosixPath: getHandlerFullPosixPath(srcPath, handler),

},

inputFiles: [],

});

} catch (e) {

logger.debug("handleBuildDotnet error", e);

onFailure(e);

}

}

function runBuildDotnet(srcPath, handler) {

// Sample input:

// srcPath 'services/user-service'

// handler 'Api::Api.MyClass::MyFn'

//

// Sample output path:

// assembly 'Api'

// absSrcPath 'services/user-service'

// absHandlerPath 'services/user-service/Api::Api.MyClass::MyFn'

// absOutputPath 'services/user-service/.build/Api-Api.MyClass-MyFn'

// outEntry 'services/user-service/.build/Api-Api.MyClass-MyFn/Api.dll'

const assembly = handler.split("::")[0];

const absSrcPath = path.join(paths.appPath, srcPath);

const absHandlerPath = path.join(paths.appPath, srcPath, handler);

// On Windows, you cannot have ":" in a folder name

const absOutputPath = path

.join(paths.appPath, srcPath, paths.appBuildDir, handler)

.replace(/::/g, "-");

const outEntry = path.join(absOutputPath, `${assembly}.dll`);

logger.debug(`Building ${absHandlerPath}...`);

return new Promise((resolve, reject) => {

const cp = spawn(

"dotnet",

[

"publish",

"--output",

absOutputPath,

"--configuration",

"Release",

"--framework",

"netcoreapp3.1",

"/p:GenerateRuntimeConfigurationFiles=true",

// warnings are not reported for repeated builds by default and this flag

// does a clean before build. It takes a little longer to run, but the

// warnings are consistently printed on each build.

//"/target:Rebuild",

"--self-contained",

"false",

// do not print "Build Engine version"

"-nologo",

// only print errors

"--verbosity",

process.env.DEBUG ? "minimal" : "quiet",

],

{

stdio: "inherit",

cwd: absSrcPath,

}

);

cp.on("error", (e) => {

logger.debug(".NET build error", e);

});

cp.on("close", (code) => {

logger.debug(`.NET build exited with code ${code}`);

if (code !== 0) {

reject(

new Error(

`There was an problem compiling the handler at "${absHandlerPath}".`

)

);

} else {

resolve({ outEntry });

}

});

});

}

////////////////////////////////////////

// Lambda Reloader functions - Python //

////////////////////////////////////////

function handleBuildPython({ srcPath, handler, onSuccess }) {

// ie.

// handler src/lambda.main

// outHandler main

// outEntry src/lambda

const handlerParts = handler.split(".");

const outHandler = handlerParts.pop();

const outEntry = handlerParts.join(".");

Promise.resolve("success").then(() =>

onSuccess({

outEntryPoint: {

entry: outEntry,