Using TS SDK from waspc

waspc/cli/exe/Main.hs

@@ -130,7 +130,7 @@ main = withUtf8 . (`E.catch` handleInternalErrors) $ do
 
     handleInternalErrors :: E.ErrorCall -> IO ()
     handleInternalErrors e = do
-      putStrLn $ "\nInternal Wasp error (bug in compiler):\n" ++ indent 2 (show e)
+      putStrLn $ "\nInternal Wasp error (bug in the compiler):\n" ++ indent 2 (show e)
       exitFailure
 
 -- | Sets env variables that are visible to the commands run by the CLI.

waspc/cli/src/Wasp/Cli/Command/CreateNewProject/StarterTemplates/Templating.hs

@@ -9,7 +9,7 @@ import qualified Data.Text as T
 import StrongPath (Abs, Dir, File, Path')
 import Wasp.Cli.Command.CreateNewProject.Common (defaultWaspVersionBounds)
 import Wasp.Cli.Command.CreateNewProject.ProjectDescription (NewProjectAppName, NewProjectName)
-import Wasp.Project.Analyze (findPackageJsonFile, findWaspFile)
+import Wasp.Project.Analyze (WaspFile (..), findPackageJsonFile, findWaspFile)
 import Wasp.Project.Common (WaspProjectDir)
 import qualified Wasp.Util.IO as IOUtil
 
@@ -26,7 +26,10 @@ replaceTemplatePlaceholdersInWaspFile ::
 replaceTemplatePlaceholdersInWaspFile appName projectName projectDir =
   findWaspFile projectDir >>= \case
     Nothing -> return ()
-    Just absMainWaspFile -> replaceTemplatePlaceholdersInFileOnDisk appName projectName absMainWaspFile
+    Just (WaspLang absMainWaspFile) -> replaceTemplatePlaceholders absMainWaspFile
+    Just (WaspTs absMainTsFile) -> replaceTemplatePlaceholders absMainTsFile
+  where
+    replaceTemplatePlaceholders = replaceTemplatePlaceholdersInFileOnDisk appName projectName
 
 -- | Template file for package.json file has placeholders in it that we want to replace
 -- in the package.json file we have written to the disk.

waspc/src/Wasp/Error.hs

@@ -1,8 +1,9 @@
 module Wasp.Error (showCompilerErrorForTerminal) where
 
 import Data.List (intercalate)
-import StrongPath (Abs, File', Path')
+import StrongPath (Abs, Path')
 import qualified StrongPath as SP
+import StrongPath.Types (File)
 import Wasp.Analyzer.Parser.Ctx (Ctx, getCtxRgn)
 import Wasp.Analyzer.Parser.SourcePosition (SourcePosition (..))
 import Wasp.Analyzer.Parser.SourceRegion (SourceRegion (..))
@@ -12,7 +13,7 @@ import qualified Wasp.Util.Terminal as T
 -- | Transforms compiler error (error with parse context) into an informative, pretty String that
 -- can be printed directly into the terminal. It uses terminal features like escape codes
 -- (colors, styling, ...).
-showCompilerErrorForTerminal :: (Path' Abs File', String) -> (String, Ctx) -> String
+showCompilerErrorForTerminal :: (Path' Abs (File f), String) -> (String, Ctx) -> String
 showCompilerErrorForTerminal (waspFilePath, waspFileContent) (errMsg, errCtx) =
   let srcRegion = getCtxRgn errCtx
    in intercalate

waspc/src/Wasp/Project/Analyze.hs

@@ -1,32 +1,45 @@
 module Wasp.Project.Analyze
   ( analyzeWaspProject,
-    readPackageJsonFile,
     analyzeWaspFileContent,
     findWaspFile,
     findPackageJsonFile,
     analyzePrismaSchema,
+    WaspFile (..),
   )
 where
 
+import Control.Applicative ((<|>))
 import Control.Arrow (ArrowChoice (left))
+import Control.Concurrent (newChan)
+import Control.Concurrent.Async (concurrently)
+import Control.Monad.Except (ExceptT (..), runExceptT)
 import qualified Data.Aeson as Aeson
+import Data.Conduit.Process.Typed (ExitCode (..))
 import Data.List (find, isSuffixOf)
-import StrongPath (Abs, Dir, File', Path', toFilePath, (</>))
+import StrongPath (Abs, Dir, File', Path', Rel, basename, toFilePath, (</>))
+import qualified StrongPath as SP
+import StrongPath.TH (relfile)
+import StrongPath.Types (File)
 import qualified Wasp.Analyzer as Analyzer
 import Wasp.Analyzer.AnalyzeError (getErrorMessageAndCtx)
 import Wasp.Analyzer.Parser.Ctx (Ctx)
 import qualified Wasp.AppSpec as AS
+import Wasp.AppSpec.Core.Decl.JSON ()
 import Wasp.AppSpec.PackageJson (PackageJson)
 import qualified Wasp.AppSpec.Valid as ASV
 import Wasp.CompileOptions (CompileOptions)
 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.Process (runNodeCommandAsJob)
 import Wasp.Project.Common
   ( CompileError,
     CompileWarning,
     WaspProjectDir,
+    dotWaspDirInWaspProjectDir,
     findFileInWaspProjectDir,
     packageJsonInWaspProjectDir,
     prismaSchemaFileInWaspProjectDir,
@@ -42,7 +55,9 @@ import qualified Wasp.Psl.Parser.Schema as Psl.Parser
 import Wasp.Psl.Valid (getValidDbSystemFromPrismaSchema)
 import qualified Wasp.Psl.Valid as PslV
 import Wasp.Util (maybeToEither)
+import Wasp.Util.Aeson (encodeToString)
 import qualified Wasp.Util.IO as IOUtil
+import Wasp.Util.StrongPath (replaceRelExtension)
 import Wasp.Valid (ValidationError)
 import qualified Wasp.Valid as Valid
 
@@ -60,7 +75,7 @@ analyzeWaspProject waspDir options = do
         (Left prismaSchemaErrors, prismaSchemaWarnings) -> return (Left prismaSchemaErrors, prismaSchemaWarnings)
         -- NOTE: we are ignoring prismaSchemaWarnings if the schema was parsed successfully
         (Right prismaSchemaAst, _) ->
-          analyzeWaspFile prismaSchemaAst waspFilePath >>= \case
+          analyzeWaspFile waspDir prismaSchemaAst waspFilePath >>= \case
             Left errors -> return (Left errors, [])
             Right declarations ->
               analyzePackageJsonContent waspDir >>= \case
@@ -69,8 +84,107 @@ 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
+data WaspFile
+  = WaspLang !(Path' Abs (File WaspLangFile))
+  | WaspTs !(Path' Abs (File WaspTsFile))
+
+data WaspLangFile
+
+data WaspTsFile
+
+data CompiledWaspJsFile
+
+data DeclsJsonFile
+
+analyzeWaspFile :: Path' Abs (Dir WaspProjectDir) -> Psl.Schema.Schema -> WaspFile -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspFile waspDir prismaSchemaAst = \case
+  WaspLang waspFilePath -> analyzeWaspLangFile prismaSchemaAst waspFilePath
+  WaspTs waspFilePath -> analyzeWaspTsFile waspDir prismaSchemaAst waspFilePath
+
+analyzeWaspTsFile :: Path' Abs (Dir WaspProjectDir) -> Psl.Schema.Schema -> Path' Abs (File WaspTsFile) -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspTsFile waspProjectDir prismaSchemaAst waspFilePath = runExceptT $ do
+  -- TODO: I'm not yet sure where tsconfig.node.json location should come from
+  -- because we also need that knowledge when generating a TS SDK project.
+  compiledWaspJsFile <- ExceptT $ compileWaspTsFile waspProjectDir [relfile|tsconfig.node.json|] waspFilePath
+  declsJsonFile <- ExceptT $ executeMainWaspJsFile waspProjectDir prismaSchemaAst compiledWaspJsFile
+  ExceptT $ readDeclsFromJsonFile declsJsonFile
+
+compileWaspTsFile ::
+  Path' Abs (Dir WaspProjectDir) ->
+  Path' (Rel WaspProjectDir) File' ->
+  Path' Abs (File WaspTsFile) ->
+  IO (Either [CompileError] (Path' Abs (File CompiledWaspJsFile)))
+compileWaspTsFile waspProjectDir tsconfigNodeFileInWaspProjectDir waspFilePath = do
+  chan <- newChan
+  (_, tscExitCode) <-
+    concurrently
+      (readJobMessagesAndPrintThemPrefixed chan)
+      ( runNodeCommandAsJob
+          waspProjectDir
+          "npx"
+          [ "tsc",
+            "-p",
+            toFilePath (waspProjectDir </> tsconfigNodeFileInWaspProjectDir),
+            "--noEmit",
+            "false",
+            "--outDir",
+            toFilePath outDir
+          ]
+          J.Wasp
+          chan
+      )
+  case tscExitCode of
+    ExitFailure _status -> return $ Left ["Got TypeScript compiler errors for " ++ toFilePath waspFilePath ++ "."]
+    ExitSuccess -> return $ Right absCompiledWaspJsFile
+  where
+    outDir = waspProjectDir </> dotWaspDirInWaspProjectDir
+    absCompiledWaspJsFile = outDir </> compiledWaspJsFileInDotWaspDir
+    compiledWaspJsFileInDotWaspDir = SP.castFile $ case replaceRelExtension (basename waspFilePath) ".mjs" of
+      Just path -> path
+      Nothing -> error $ "Couldn't calculate the compiled JS file path for " ++ toFilePath waspFilePath ++ "."
+
+executeMainWaspJsFile ::
+  Path' Abs (Dir WaspProjectDir) ->
+  Psl.Schema.Schema ->
+  Path' Abs (File CompiledWaspJsFile) ->
+  IO (Either [CompileError] (Path' Abs (File DeclsJsonFile)))
+executeMainWaspJsFile waspProjectDir prismaSchemaAst absCompiledMainWaspJsFile = do
+  chan <- newChan
+  (_, runExitCode) <- do
+    concurrently
+      (readJobMessagesAndPrintThemPrefixed chan)
+      ( runNodeCommandAsJob
+          waspProjectDir
+          "npx"
+          -- TODO: Figure out how to keep running instructions in a single
+          -- place (e.g., this is string the same as the package name, but it's
+          -- repeated in two places).
+          -- Before this, I had the entrypoint file hardcoded, which was bad
+          -- too: waspProjectDir </> [relfile|node_modules/wasp-config/dist/run.js|]
+          [ "wasp-config",
+            SP.fromAbsFile absCompiledMainWaspJsFile,
+            SP.fromAbsFile absDeclsOutputFile,
+            encodeToString allowedEntityNames
+          ]
+          J.Wasp
+          chan
+      )
+  case runExitCode of
+    ExitFailure _status -> return $ Left ["Error while running the compiled *.wasp.mts file."]
+    ExitSuccess -> return $ Right absDeclsOutputFile
+  where
+    absDeclsOutputFile = waspProjectDir </> dotWaspDirInWaspProjectDir </> [relfile|decls.json|]
+    allowedEntityNames = Psl.Schema.getModelNames prismaSchemaAst
+
+readDeclsFromJsonFile :: Path' Abs (File DeclsJsonFile) -> IO (Either [CompileError] [AS.Decl])
+readDeclsFromJsonFile declsJsonFile = do
+  declsBytestring <- IOUtil.readFileBytes declsJsonFile
+  case Aeson.eitherDecode declsBytestring of
+    Right value -> return $ Right value
+    Left err -> return $ Left ["Error while parsing the declarations from JSON: " ++ err]
+
+analyzeWaspLangFile :: Psl.Schema.Schema -> Path' Abs (File WaspLangFile) -> IO (Either [CompileError] [AS.Decl])
+analyzeWaspLangFile prismaSchemaAst waspFilePath = do
   waspFileContent <- IOUtil.readFile waspFilePath
   left (map $ showCompilerErrorForTerminal (waspFilePath, waspFileContent))
     <$> analyzeWaspFileContent prismaSchemaAst waspFileContent
@@ -118,15 +232,14 @@ constructAppSpec waspDir options packageJson parsedPrismaSchema decls = do
 
   return $ runValidation ASV.validateAppSpec appSpec
 
-findWaspFile :: Path' Abs (Dir WaspProjectDir) -> IO (Maybe (Path' Abs File'))
+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
-        && (length (toFilePath path) > length (".wasp" :: String))
+    findWaspTsFile files = WaspTs <$> findFileThatEndsWith ".wasp.mts" files
+    findWaspLangFile files = WaspLang <$> findFileThatEndsWith ".wasp" files
+    findFileThatEndsWith suffix files = SP.castFile . (waspDir </>) <$> find ((suffix `isSuffixOf`) . toFilePath) files
 
 analyzePackageJsonContent :: Path' Abs (Dir WaspProjectDir) -> IO (Either [CompileError] PackageJson)
 analyzePackageJsonContent waspProjectDir =

waspc/src/Wasp/Project/Common.hs

@@ -22,6 +22,7 @@ module Wasp.Project.Common
 where
 
 import StrongPath (Abs, Dir, File', Path', Rel, reldir, relfile, toFilePath, (</>))
+import StrongPath.Types (File)
 import System.Directory (doesFileExist)
 import Wasp.AppSpec.ExternalFiles (SourceExternalCodeDir, SourceExternalPublicDir)
 import qualified Wasp.Generator.Common
@@ -86,8 +87,8 @@ tsconfigInWaspProjectDir = [relfile|tsconfig.json|]
 
 findFileInWaspProjectDir ::
   Path' Abs (Dir WaspProjectDir) ->
-  Path' (Rel WaspProjectDir) File' ->
-  IO (Maybe (Path' Abs File'))
+  Path' (Rel WaspProjectDir) (File f) ->
+  IO (Maybe (Path' Abs (File f)))
 findFileInWaspProjectDir waspDir file = do
   let fileAbsFp = waspDir </> file
   fileExists <- doesFileExist $ toFilePath fileAbsFp

waspc/src/Wasp/Psl/Ast/Model.hs

@@ -7,7 +7,7 @@ module Wasp.Psl.Ast.Model
     Field (..),
     FieldType (..),
     FieldTypeModifier (..),
-    getFields,
+    getName,
   )
 where
 
@@ -60,5 +60,5 @@ data FieldTypeModifier
   | Optional
   deriving (Show, Eq, Data)
 
-getFields :: Model -> [Field]
-getFields (Model _ (Body elements)) = [field | ElementField field <- elements]
+getName :: Model -> Name
+getName (Model name _) = name

waspc/src/Wasp/Psl/Ast/Schema.hs

@@ -7,13 +7,15 @@ module Wasp.Psl.Ast.Schema
     getEnums,
     getDatasources,
     getGenerators,
+    getModelNames,
   )
 where
 
 import Wasp.Psl.Ast.ConfigBlock (ConfigBlock)
 import qualified Wasp.Psl.Ast.ConfigBlock as Psl.ConfigBlock
 import Wasp.Psl.Ast.Enum (Enum)
 import Wasp.Psl.Ast.Model (Model)
+import qualified Wasp.Psl.Ast.Model as Model
 import Wasp.Psl.Ast.Type (Type)
 import Wasp.Psl.Ast.View (View)
 import Prelude hiding (Enum)
@@ -49,3 +51,6 @@ getGenerators schema = [generator | generator@((Psl.ConfigBlock.ConfigBlock Psl.
 
 getConfigBlocks :: Schema -> [ConfigBlock]
 getConfigBlocks (Schema blocks) = [configBlock | ConfigBlock configBlock <- blocks]
+
+getModelNames :: Schema -> [String]
+getModelNames schema = map Model.getName $ getModels schema

waspc/src/Wasp/Util/Aeson.hs

@@ -1,10 +1,11 @@
 module Wasp.Util.Aeson
   ( encodeToText,
     decodeFromString,
+    encodeToString,
   )
 where
 
-import Data.Aeson (FromJSON, ToJSON, eitherDecode)
+import Data.Aeson (FromJSON, ToJSON, eitherDecode, encode)
 import Data.Aeson.Text (encodeToTextBuilder)
 import qualified Data.ByteString.Lazy.UTF8 as BS
 import Data.Text (Text)
@@ -16,3 +17,6 @@ encodeToText = toStrict . toLazyText . encodeToTextBuilder
 
 decodeFromString :: FromJSON a => String -> Either String a
 decodeFromString = eitherDecode . BS.fromString
+
+encodeToString :: ToJSON a => a -> String
+encodeToString = BS.toString . encode

waspc/test/AppSpec/FromJSONTest.hs

@@ -94,16 +94,6 @@ spec_AppSpecFromJSON = do
           }
         |]
         `shouldDecodeTo` Just (Ref.Ref "foo" :: Ref Query)
-    it "fails to parse an invalid declType" $ do
-      [trimming|
-          {
-            "name": "foo",
-            "declType": "IMadeThisUp"
-          }
-        |]
-        -- NOTE: We are using `Ref Entity` here, because the Show instance in
-        -- shouldDecodeTo demands a proper type.
-        `shouldDecodeTo` (Nothing :: Maybe (Ref Entity))
   describe "Query" $ do
     it "parses a valid Query JSON with auth and entities" $ do
       [trimming|

waspc/waspc.cabal

@@ -456,7 +456,6 @@ library waspls
     Wasp.LSP.TypeInference
     Wasp.LSP.Util
     Wasp.LSP.Prisma.Analyze
-    Wasp.LSP.Prisma.Util
   build-depends:
       base
     , aeson

waspc/waspls/src/Wasp/LSP/Prisma/Analyze.hs

@@ -4,11 +4,11 @@ import Control.Lens ((.~))
 import Control.Monad.Cont (liftIO)
 import Control.Monad.Log.Class (logM)
 import StrongPath (Abs, Dir, Path')
-import Wasp.LSP.Prisma.Util (showModelNames)
 import Wasp.LSP.ServerMonads (ServerM, modify)
 import qualified Wasp.LSP.ServerState as State
 import Wasp.Project (WaspProjectDir)
 import Wasp.Project.Analyze (analyzePrismaSchema)
+import Wasp.Psl.Ast.Schema (getModelNames)
 
 analyzeAndSetPrismaSchema :: Path' Abs (Dir WaspProjectDir) -> ServerM ()
 analyzeAndSetPrismaSchema waspDir = do
@@ -18,7 +18,7 @@ analyzeAndSetPrismaSchema waspDir = do
       logOutput "warnings" $ show warnings
     (Right prismaSchemaAst, warnings) -> do
       logOutput "warnings" $ show warnings
-      logOutput "models" $ showModelNames prismaSchemaAst
+      logOutput "models" $ show $ getModelNames prismaSchemaAst
       modify (State.prismaSchemaAst .~ prismaSchemaAst)
   where
     logOutput :: String -> String -> ServerM ()