Small fixes in the generator

waspc/src/Wasp/AppSpec/Job.hs

@@ -39,8 +39,6 @@ data Perform = Perform
   }
   deriving (Show, Eq, Data)
 
-instance IsDecl Perform
-
 -- Allows jobs to run via some cron schedule.
 data Schedule = Schedule
   { cron :: String, -- 5 field cron expression, exe: "*/5 * * * *".
@@ -49,13 +47,10 @@ data Schedule = Schedule
   }
   deriving (Show, Eq, Data)
 
-instance IsDecl Schedule
-
 -- These are optional executor-specific JSON options we pass
 -- directly through to the executor when submitting jobs.
 data ExecutorOptions = ExecutorOptions
-  { pgBoss :: Maybe JSON,
-    simple :: Maybe JSON
+  { pgBoss :: Maybe JSON
   }
   deriving (Show, Eq, Data)
 

waspc/src/Wasp/Generator/DbGenerator.hs

@@ -258,7 +258,7 @@ generatePrismaClient spec projectRootDir = do
     generatePrismaClientIfEntitiesExist :: IO (Maybe GeneratorError)
     generatePrismaClientIfEntitiesExist
       | entitiesExist =
-          either (Just . GenericGeneratorError) (const Nothing) <$> DbOps.generatePrismaClient projectRootDir
+        either (Just . GenericGeneratorError) (const Nothing) <$> DbOps.generatePrismaClient projectRootDir
       | otherwise = return Nothing
 
     entitiesExist = not . null $ getEntities spec

waspc/src/Wasp/Generator/Setup.hs

@@ -22,8 +22,8 @@ runSetup spec projectRootDir sendMessage = do
         setUpDatabaseResults@(_warnings, _errors@[]) -> do
           -- todo(filip): Should we consider building SDK as part of code generation?
           -- todo(filip): Avoid building on each setup if we don't need to.
-          buildsSdkResults <- buildSdk projectRootDir sendMessage
-          return $ setUpDatabaseResults <> buildsSdkResults
+          buildSdkResults <- buildSdk projectRootDir sendMessage
+          return $ setUpDatabaseResults <> buildSdkResults
         setUpDatabaseResults -> return setUpDatabaseResults
     Left npmInstallError -> return ([], [npmInstallError])
 

waspc/src/Wasp/Project/Analyze.hs

@@ -5,13 +5,24 @@ module Wasp.Project.Analyze
     findWaspFile,
     findPackageJsonFile,
     analyzePrismaSchema,
+    WaspFile (..),
   )
 where
 
+import Control.Applicative ((<|>))
 import Control.Arrow (ArrowChoice (left))
+import Control.Concurrent (newChan, readChan)
+import Control.Concurrent.Async (concurrently)
+import Control.Concurrent.Chan (Chan)
+import Control.Monad.IO.Class (liftIO)
 import qualified Data.Aeson as Aeson
+import qualified Data.Conduit.Combinators as T
+import Data.Conduit.Process.Typed (ExitCode (..))
 import Data.List (find, isSuffixOf)
+import qualified Data.Text as T
 import StrongPath (Abs, Dir, File', Path', toFilePath, (</>))
+import qualified StrongPath as SP
+import StrongPath.Types (File)
 import qualified Wasp.Analyzer as Analyzer
 import Wasp.Analyzer.AnalyzeError (getErrorMessageAndCtx)
 import Wasp.Analyzer.Parser.Ctx (Ctx)
@@ -23,6 +34,10 @@ import qualified Wasp.CompileOptions as CompileOptions
 import qualified Wasp.ConfigFile as CF
 import Wasp.Error (showCompilerErrorForTerminal)
 import qualified Wasp.Generator.ConfigFile as G.CF
+import qualified Wasp.Generator.Job as J
+import Wasp.Generator.Job.IO (readJobMessagesAndPrintThemPrefixed)
+import Wasp.Generator.Job.IO.PrefixedWriter (printJobMessagePrefixed, runPrefixedWriter)
+import Wasp.Generator.Job.Process (runNodeCommandAsJob)
 import Wasp.Project.Common
   ( CompileError,
     CompileWarning,
@@ -69,8 +84,57 @@ analyzeWaspProject waspDir options = do
   where
     fileNotFoundMessage = "Couldn't find the *.wasp file in the " ++ toFilePath waspDir ++ " directory"
 
-analyzeWaspFile :: Psl.Schema.Schema -> Path' Abs File' -> IO (Either [CompileError] [AS.Decl])
-analyzeWaspFile prismaSchemaAst waspFilePath = do
+analyzeWaspFile :: Psl.Schema.Schema -> WaspFile -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspFile prismaSchemaAst = \case
+  WaspLangFile waspFilePath -> analyzeWaspLangFile prismaSchemaAst waspFilePath
+  WaspTsFile waspFilePath -> analyzeWaspTsFile prismaSchemaAst waspFilePath
+
+analyzeWaspTsFile :: Psl.Schema.Schema -> Path' Abs File' -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspTsFile _prismaSchemaAst waspFilePath = do
+  let workingDir = SP.parent waspFilePath
+  chan <- newChan
+  (_, tscExitCode) <-
+    concurrently
+      (readJobMessagesAndPrintThemPrefixed chan)
+      (runNodeCommandAsJob workingDir "npx" ["tsc", "-p", "tsconfig.node.json"] J.Wasp chan)
+
+  case tscExitCode of
+    ExitFailure _status -> return $ Left ["Error while running TypeScript compiler on the *.wasp.mts file."]
+    ExitSuccess -> do
+      otherChan <- newChan
+      (_, runExitCode) <-
+        concurrently
+          (handleRunJsMessages otherChan)
+          ( runNodeCommandAsJob
+              workingDir
+              "node"
+              [ SP.fromAbsDir workingDir ++ "node_modules/wasp-ts-sdk/dist/run.js",
+                SP.fromAbsDir workingDir ++ ".wasp/config/main.wasp.mjs"
+              ]
+              J.Wasp
+              otherChan
+          )
+      case runExitCode of
+        ExitFailure _status -> return $ Left ["Error while running the compiled *.wasp.mts file."]
+        ExitSuccess -> return $ Right []
+  where
+    handleRunJsMessages :: Chan J.JobMessage -> IO ()
+    handleRunJsMessages = runPrefixedWriter . processMessages
+    processMessages chan = do
+      jobMsg <- liftIO $ readChan chan
+      case J._data jobMsg of
+        J.JobOutput payload J.Stdout -> do
+          -- let payload:: String = read $ T.unpack text
+          liftIO $ putStrLn "Ovo smo dobili na stdout"
+          -- parse payload as json
+          let json = Aeson.toJSON payload
+          liftIO $ print json
+          return ()
+        J.JobOutput _ J.Stderr -> printJobMessagePrefixed jobMsg >> processMessages chan
+        J.JobExit {} -> return ()
+
+analyzeWaspLangFile :: Psl.Schema.Schema -> Path' Abs File' -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspLangFile prismaSchemaAst waspFilePath = do
   waspFileContent <- IOUtil.readFile waspFilePath
   left (map $ showCompilerErrorForTerminal (waspFilePath, waspFileContent))
     <$> analyzeWaspFileContent prismaSchemaAst waspFileContent
@@ -118,16 +182,25 @@ constructAppSpec waspDir options packageJson parsedPrismaSchema decls = do
 
   return $ runValidation ASV.validateAppSpec appSpec
 
-findWaspFile :: Path' Abs (Dir WaspProjectDir) -> IO (Maybe (Path' Abs File'))
+data WaspFile
+  = WaspLangFile {_path :: !(Path' Abs File')}
+  | WaspTsFile {_path :: !(Path' Abs File')}
+  deriving (Show)
+
+findWaspFile :: Path' Abs (Dir WaspProjectDir) -> IO (Maybe WaspFile)
 findWaspFile waspDir = do
   files <- fst <$> IOUtil.listDirectory waspDir
-  return $ (waspDir </>) <$> find isWaspFile files
+  return $ findWaspTsFile files <|> findWaspLangFile files
   where
-    isWaspFile path =
-      ".wasp"
-        `isSuffixOf` toFilePath path
+    findWaspTsFile files = WaspTsFile . (waspDir </>) <$> find (`hasExtension` ".wasp.mts") files
+    findWaspLangFile files = WaspLangFile . (waspDir </>) <$> find isWaspLangFile files
+    isWaspLangFile path =
+      path `hasExtension` ".wasp"
         && (length (toFilePath path) > length (".wasp" :: String))
 
+hasExtension :: Path' s (File f) -> String -> Bool
+hasExtension path ext = ext `isSuffixOf` toFilePath path
+
 analyzePackageJsonContent :: Path' Abs (Dir WaspProjectDir) -> IO (Either [CompileError] PackageJson)
 analyzePackageJsonContent waspProjectDir =
   findPackageJsonFile waspProjectDir >>= \case

waspc/test/AnalyzerTest.hs

@@ -269,8 +269,7 @@ spec_Analyzer = do
               )
               ( Just $
                   Job.ExecutorOptions
-                    { Job.pgBoss = JSON.JSON <$> Aeson.decode "{\"retryLimit\":1}",
-                      Job.simple = Nothing
+                    { Job.pgBoss = JSON.JSON <$> Aeson.decode "{\"retryLimit\":1}"
                     }
               )
       let jobSchedule =
@@ -279,8 +278,7 @@ spec_Analyzer = do
               (JSON.JSON <$> Aeson.decode "{\"job\":\"args\"}")
               ( Just $
                   Job.ExecutorOptions
-                    { Job.pgBoss = JSON.JSON <$> Aeson.decode "{\"retryLimit\":0}",
-                      Job.simple = Nothing
+                    { Job.pgBoss = JSON.JSON <$> Aeson.decode "{\"retryLimit\":0}"
                     }
               )
       let expectedJob =