Create wasp build start command

waspc/ChangeLog.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### 🎉 New Features
+
+- New command: `wasp build start`. It allows you to run your built Wasp app as it would run in your production server. Useful for testing your production build locally, and making sure of passing the correct environment variables. [#2796](https://github.com/wasp-lang/wasp/pull/2796)
+
 ## 0.17.0
 
 ### ⚠️ Breaking Changes

waspc/cli/exe/Main.hs

@@ -13,6 +13,7 @@ import System.Exit (exitFailure)
 import Wasp.Cli.Command (runCommand)
 import Wasp.Cli.Command.BashCompletion (bashCompletion, generateBashCompletionScript, printBashCompletionInstruction)
 import Wasp.Cli.Command.Build (build)
+import Wasp.Cli.Command.BuildStart (buildStart)
 import qualified Wasp.Cli.Command.Call as Command.Call
 import Wasp.Cli.Command.Clean (clean)
 import Wasp.Cli.Command.Compile (compile)
@@ -58,6 +59,7 @@ main = withUtf8 . (`E.catch` handleInternalErrors) $ do
         ["uninstall"] -> Command.Call.Uninstall
         ["version"] -> Command.Call.Version
         ["build"] -> Command.Call.Build
+        ("build" : "start" : buildStartArgs) -> Command.Call.BuildStart buildStartArgs
         ["telemetry"] -> Command.Call.Telemetry
         ["deps"] -> Command.Call.Deps
         ["dockerfile"] -> Command.Call.Dockerfile
@@ -111,6 +113,7 @@ main = withUtf8 . (`E.catch` handleInternalErrors) $ do
     Command.Call.Studio -> runCommand studio
     Command.Call.Uninstall -> runCommand uninstall
     Command.Call.Build -> runCommand build
+    Command.Call.BuildStart buildStartArgs -> runCommand $ buildStart buildStartArgs
     Command.Call.Telemetry -> runCommand Telemetry.telemetry
     Command.Call.Deps -> runCommand deps
     Command.Call.Dockerfile -> runCommand printDockerfile
@@ -179,6 +182,7 @@ printUsage =
         cmd   "    clean                 Deletes all generated code, all cached artifacts, and the node_modules dir.",
               "                          Wasp equivalent of 'have you tried closing and opening it again?'.",
         cmd   "    build                 Generates full web app code, ready for deployment. Use when deploying or ejecting.",
+        cmd   "    build start [args]    Previews the built production app locally.",
         cmd   "    deploy                Deploys your Wasp app to cloud hosting providers.",
         cmd   "    telemetry             Prints telemetry status.",
         cmd   "    deps                  Prints the dependencies that Wasp uses in your project.",

waspc/cli/src/Wasp/Cli/Command/BuildStart.hs

@@ -0,0 +1,78 @@
+module Wasp.Cli.Command.BuildStart
+  ( buildStart,
+  )
+where
+
+import Control.Concurrent.Async (concurrently)
+import Control.Concurrent.Chan (newChan)
+import Control.Monad.Except (MonadError (throwError), runExceptT)
+import Control.Monad.IO.Class (liftIO)
+import Data.Function ((&))
+import Wasp.Cli.Command (Command, CommandError (CommandError), require)
+import Wasp.Cli.Command.BuildStart.ArgumentsParser (buildStartArgsParser)
+import Wasp.Cli.Command.BuildStart.Client (buildClient, startClient)
+import Wasp.Cli.Command.BuildStart.Config (BuildStartConfig, makeBuildStartConfig)
+import Wasp.Cli.Command.BuildStart.Server (buildServer, startServer)
+import Wasp.Cli.Command.Call (Arguments)
+import Wasp.Cli.Command.Compile (analyze)
+import Wasp.Cli.Command.Message (cliSendMessageC)
+import Wasp.Cli.Command.Require (BuildDirExists (BuildDirExists), InWaspProject (InWaspProject))
+import Wasp.Cli.Util.Parser (parseArguments)
+import Wasp.Job.Except (ExceptJob)
+import qualified Wasp.Job.Except as ExceptJob
+import Wasp.Job.IO (readJobMessagesAndPrintThemPrefixed)
+import qualified Wasp.Message as Msg
+
+buildStart :: Arguments -> Command ()
+buildStart args = do
+  buildStartArgs <-
+    parseArguments "wasp build start" buildStartArgsParser args
+      & either (throwError . CommandError "Parsing arguments failed") return
+
+  BuildDirExists _ <- require
+
+  InWaspProject waspProjectDir <- require
+  appSpec <- analyze waspProjectDir
+
+  -- TODO: Find a way to easily check we can connect to the DB. We'd like to
+  -- throw a clear error if not available. (See #2858)
+  --
+  -- It is not a big problem right now, because Prisma will fail shortly after
+  -- the server starts if the DB is not running anyway, and with a very clear
+  -- error message that we print.
+
+  config <- makeBuildStartConfig appSpec buildStartArgs waspProjectDir
+
+  buildAndStartServerAndClient config
+
+buildAndStartServerAndClient :: BuildStartConfig -> Command ()
+buildAndStartServerAndClient config = do
+  cliSendMessageC $ Msg.Start "Building client..."
+  runAndPrintJob "Building client failed." $
+    buildClient config
+  cliSendMessageC $ Msg.Success "Client built."
+
+  cliSendMessageC $ Msg.Start "Building server..."
+  runAndPrintJob "Building server failed." $
+    buildServer config
+  cliSendMessageC $ Msg.Success "Server built."
+
+  cliSendMessageC $ Msg.Start "Starting client and server..."
+  runAndPrintJob "Starting Wasp app failed." $
+    ExceptJob.race_
+      (startClient config)
+      (startServer config)
+  where
+    runAndPrintJob :: String -> ExceptJob -> Command ()
+    runAndPrintJob errorMessage job = do
+      liftIO (runAndPrintJobIO job)
+        >>= either (throwError . CommandError errorMessage) return
+
+    runAndPrintJobIO :: ExceptJob -> IO (Either String ())
+    runAndPrintJobIO job = do
+      chan <- newChan
+      (result, _) <-
+        concurrently
+          (runExceptT $ job chan)
+          (readJobMessagesAndPrintThemPrefixed chan)
+      return result

waspc/cli/src/Wasp/Cli/Command/BuildStart/ArgumentsParser.hs

@@ -0,0 +1,50 @@
+module Wasp.Cli.Command.BuildStart.ArgumentsParser
+  ( buildStartArgsParser,
+    BuildStartArgs (..),
+  )
+where
+
+import qualified Options.Applicative as Opt
+import Wasp.Cli.Util.EnvVarArgument (EnvVarFileArgument, envVarFileReader, envVarReader)
+import Wasp.Env (EnvVar)
+
+data BuildStartArgs = BuildStartArgs
+  { clientEnvironmentVariables :: [EnvVar],
+    clientEnvironmentFiles :: [EnvVarFileArgument],
+    serverEnvironmentVariables :: [EnvVar],
+    serverEnvironmentFiles :: [EnvVarFileArgument]
+  }
+
+buildStartArgsParser :: Opt.Parser BuildStartArgs
+buildStartArgsParser =
+  BuildStartArgs
+    <$> Opt.many clientEnvironmentVariableParser
+    <*> Opt.many clientEnvironmentFileParser
+    <*> Opt.many serverEnvironmentVariableParser
+    <*> Opt.many serverEnvironmentFileParser
+  where
+    clientEnvironmentVariableParser =
+      makeEnvironmentVariableParser "client" "client-env" 'c'
+    clientEnvironmentFileParser =
+      makeEnvironmentFileParser "client" "client-env-file"
+
+    serverEnvironmentVariableParser =
+      makeEnvironmentVariableParser "server" "server-env" 's'
+    serverEnvironmentFileParser =
+      makeEnvironmentFileParser "server" "server-env-file"
+
+    makeEnvironmentVariableParser :: String -> String -> Char -> Opt.Parser EnvVar
+    makeEnvironmentVariableParser targetName longOptionName shortOptionName =
+      Opt.option envVarReader $
+        Opt.long longOptionName
+          <> Opt.short shortOptionName
+          <> Opt.metavar "NAME=VALUE"
+          <> Opt.help ("Set an environment variable for the " <> targetName <> " (can be used multiple times)")
+
+    makeEnvironmentFileParser :: String -> String -> Opt.Parser EnvVarFileArgument
+    makeEnvironmentFileParser targetName longOptionName =
+      Opt.option envVarFileReader $
+        Opt.long longOptionName
+          <> Opt.metavar "FILE_PATH"
+          <> Opt.help ("Load environment variables for the " <> targetName <> " from a file (can be used multiple times)")
+          <> Opt.action "file"

waspc/cli/src/Wasp/Cli/Command/BuildStart/Client.hs

@@ -0,0 +1,48 @@
+module Wasp.Cli.Command.BuildStart.Client
+  ( buildClient,
+    startClient,
+  )
+where
+
+import Data.Function ((&))
+import StrongPath ((</>))
+import Wasp.Cli.Command.BuildStart.Config (BuildStartConfig)
+import qualified Wasp.Cli.Command.BuildStart.Config as Config
+import qualified Wasp.Generator.WebAppGenerator.Common as WebApp
+import qualified Wasp.Job as J
+import Wasp.Job.Except (ExceptJob, toExceptJob)
+import Wasp.Job.Process (runNodeCommandAsJob, runNodeCommandAsJobWithExtraEnv)
+
+buildClient :: BuildStartConfig -> ExceptJob
+buildClient config =
+  runNodeCommandAsJobWithExtraEnv
+    envVars
+    webAppDir
+    "npm"
+    ["run", "build"]
+    J.WebApp
+    & toExceptJob (("Building the client failed with exit code: " <>) . show)
+  where
+    envVars = Config.clientEnvVars config
+    webAppDir = buildDir </> WebApp.webAppRootDirInProjectRootDir
+    buildDir = Config.buildDir config
+
+startClient :: BuildStartConfig -> ExceptJob
+startClient config =
+  runNodeCommandAsJob
+    webAppDir
+    "npm"
+    [ "run",
+      "preview", -- `preview` launches a static file server for the built client.
+      "--",
+      "--port",
+      port,
+      "--strictPort" -- This will make it fail if the port is already in use.
+    ]
+    J.WebApp
+    & toExceptJob (("Serving the client failed with exit code: " <>) . show)
+  where
+    port = show $ fst $ Config.clientPortAndUrl config
+
+    buildDir = Config.buildDir config
+    webAppDir = buildDir </> WebApp.webAppRootDirInProjectRootDir

waspc/cli/src/Wasp/Cli/Command/BuildStart/Config.hs

@@ -0,0 +1,121 @@
+module Wasp.Cli.Command.BuildStart.Config
+  ( BuildStartConfig,
+    buildDir,
+    clientEnvVars,
+    clientPortAndUrl,
+    dockerContainerName,
+    dockerImageName,
+    makeBuildStartConfig,
+    serverEnvVars,
+    serverUrl,
+  )
+where
+
+import Control.Monad.Except (MonadError (throwError), MonadIO (liftIO))
+import Data.Char (toLower)
+import Data.List (intercalate)
+import StrongPath ((</>))
+import qualified StrongPath as SP
+import Wasp.AppSpec (AppSpec)
+import qualified Wasp.AppSpec.Valid as ASV
+import Wasp.Cli.Command (Command, CommandError (CommandError))
+import Wasp.Cli.Command.BuildStart.ArgumentsParser (BuildStartArgs)
+import qualified Wasp.Cli.Command.BuildStart.ArgumentsParser as Args
+import Wasp.Cli.Util.EnvVarArgument (EnvVarFileArgument, readEnvVarFile)
+import Wasp.Env (EnvVar, forceEnvVars, nubEnvVars)
+import Wasp.Generator.Common (ProjectRootDir)
+import Wasp.Generator.ServerGenerator.Common (defaultDevServerUrl)
+import qualified Wasp.Generator.ServerGenerator.Common as Server
+import Wasp.Generator.WebAppGenerator.Common (defaultClientPort, getDefaultDevClientUrl)
+import qualified Wasp.Generator.WebAppGenerator.Common as WebApp
+import Wasp.Project.Common (WaspProjectDir, buildDirInDotWaspDir, dotWaspDirInWaspProjectDir, makeAppUniqueId)
+
+data BuildStartConfig = BuildStartConfig
+  { appUniqueId :: String,
+    clientPortAndUrl :: (Int, String),
+    serverEnvVars :: [EnvVar],
+    clientEnvVars :: [EnvVar],
+    buildDir :: SP.Path' SP.Abs (SP.Dir ProjectRootDir)
+  }
+
+makeBuildStartConfig :: AppSpec -> BuildStartArgs -> SP.Path' SP.Abs (SP.Dir WaspProjectDir) -> Command BuildStartConfig
+makeBuildStartConfig appSpec args projectDir = do
+  let config = makeBuildStartConfigWithoutEnvVars appSpec projectDir
+
+  serverEnvVars' <-
+    readAndForceEnvVars
+      [ (Server.clientUrlEnvVarName, show $ fst $ clientPortAndUrl config),
+        (Server.serverUrlEnvVarName, serverUrl config)
+      ]
+      (Args.serverEnvironmentVariables args)
+      (Args.serverEnvironmentFiles args)
+
+  clientEnvVars' <-
+    readAndForceEnvVars
+      [ (WebApp.serverUrlEnvVarName, serverUrl config)
+      ]
+      (Args.clientEnvironmentVariables args)
+      (Args.clientEnvironmentFiles args)
+
+  return $
+    config
+      { serverEnvVars = serverEnvVars',
+        clientEnvVars = clientEnvVars'
+      }
+
+makeBuildStartConfigWithoutEnvVars :: AppSpec -> SP.Path' SP.Abs (SP.Dir WaspProjectDir) -> BuildStartConfig
+makeBuildStartConfigWithoutEnvVars appSpec projectDir =
+  BuildStartConfig
+    { appUniqueId = appUniqueId',
+      buildDir = buildDir',
+      clientPortAndUrl = (clientPort, clientUrl),
+      serverEnvVars = [],
+      clientEnvVars = []
+    }
+  where
+    buildDir' = projectDir </> dotWaspDirInWaspProjectDir </> buildDirInDotWaspDir
+    appUniqueId' = makeAppUniqueId projectDir appName
+    (appName, _) = ASV.getApp appSpec
+
+    -- This assumes that `getDefaultDevClientUrl` uses `defaultClientPort` internally.
+    -- If that changes, we also need to change this.
+    clientPort = defaultClientPort
+    clientUrl = getDefaultDevClientUrl appSpec
+
+-- NOTE(carlos): For now, creating these URLs and ports below uses the default
+-- values we've hardcoded in the generator. In the future, we might want to make
+-- these configurable via the Wasp app spec or command line arguments.
+
+serverUrl :: BuildStartConfig -> String
+serverUrl _ = defaultDevServerUrl
+
+dockerImageName :: BuildStartConfig -> String
+dockerImageName config =
+  map toLower $ -- Lowercase because Docker image names require it.
+    appUniqueId config <> "-server"
+
+dockerContainerName :: BuildStartConfig -> String
+dockerContainerName config =
+  map toLower $ -- Lowercase because Docker container names require it.
+    appUniqueId config <> "-server-container"
+
+readAndForceEnvVars :: [EnvVar] -> [EnvVar] -> [EnvVarFileArgument] -> Command [EnvVar]
+readAndForceEnvVars forced existing files = do
+  readVars <- liftIO $ readEnvVars existing files
+  forceEnvVarsCommand forced readVars
+
+readEnvVars :: [EnvVar] -> [EnvVarFileArgument] -> IO [EnvVar]
+readEnvVars pairs files = do
+  pairsFromFiles <- mapM readEnvVarFile files
+  let allEnvVars = pairs <> concat pairsFromFiles
+  return $ nubEnvVars allEnvVars
+
+forceEnvVarsCommand :: [EnvVar] -> [EnvVar] -> Command [EnvVar]
+forceEnvVarsCommand forced existing =
+  case forceEnvVars forced existing of
+    Left duplicateNames ->
+      throwError $
+        CommandError "Duplicate environment variables" $
+          ("The following environment variables will be overwritten by Wasp and should be removed: " <>) $
+            intercalate ", " duplicateNames
+    Right combined -> return combined

waspc/cli/src/Wasp/Cli/Command/BuildStart/Server.hs

@@ -0,0 +1,45 @@
+module Wasp.Cli.Command.BuildStart.Server
+  ( buildServer,
+    startServer,
+  )
+where
+
+import Data.Function ((&))
+import qualified StrongPath as SP
+import System.Process (proc)
+import Wasp.Cli.Command.BuildStart.Config (BuildStartConfig)
+import qualified Wasp.Cli.Command.BuildStart.Config as Config
+import qualified Wasp.Job as J
+import Wasp.Job.Except (ExceptJob, toExceptJob)
+import Wasp.Job.Process (runProcessAsJob)
+
+buildServer :: BuildStartConfig -> ExceptJob
+buildServer config =
+  runProcessAsJob
+    (proc "docker" ["build", "--tag", dockerImageName, dockerContextDir])
+    J.Server
+    & toExceptJob (("Building the server failed with exit code: " <>) . show)
+  where
+    dockerContextDir = SP.fromAbsDir buildDir
+    buildDir = Config.buildDir config
+    dockerImageName = Config.dockerImageName config
+
+startServer :: BuildStartConfig -> ExceptJob
+startServer config =
+  runProcessAsJob
+    ( proc
+        "docker"
+        ( ["run", "--name", dockerContainerName, "--rm", "--network", "host"]
+            <> envVarParams
+            <> [dockerImageName]
+        )
+    )
+    J.Server
+    & toExceptJob (("Running the server failed with exit code: " <>) . show)
+  where
+    envVarParams = toEnvVarParams $ Config.serverEnvVars config
+    dockerContainerName = Config.dockerContainerName config
+    dockerImageName = Config.dockerImageName config
+
+    toEnvVarParams list =
+      list >>= \(name, value) -> ["--env", name <> "=" <> value]

waspc/cli/src/Wasp/Cli/Command/Call.hs

@@ -11,6 +11,7 @@ data Call
   | Compile
   | Db Arguments -- db args
   | Build
+  | BuildStart Arguments
   | Version
   | Telemetry
   | Deps