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 (findWaspFile)
+import Wasp.Project.Analyze (WaspFilePath (..), findWaspFile)
 import Wasp.Project.Common (WaspProjectDir)
 import Wasp.Project.ExternalConfig.PackageJson (findPackageJsonFile)
 import qualified Wasp.Util.IO as IOUtil
@@ -26,8 +26,11 @@ replaceTemplatePlaceholdersInWaspFile ::
   NewProjectAppName -> NewProjectName -> Path' Abs (Dir WaspProjectDir) -> IO ()
 replaceTemplatePlaceholdersInWaspFile appName projectName projectDir =
   findWaspFile projectDir >>= \case
-    Nothing -> return ()
-    Just absMainWaspFile -> replaceTemplatePlaceholdersInFileOnDisk appName projectName absMainWaspFile
+    Left _error -> return ()
+    Right (WaspLang absMainWaspFile) -> replaceTemplatePlaceholders absMainWaspFile
+    Right (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/Analyzer.hs

@@ -111,6 +111,7 @@ module Wasp.Analyzer
 
     -- * API
     analyze,
+    getEntityDecls,
     takeDecls,
     AnalyzeError (..),
     getErrorMessageAndCtx,
@@ -127,8 +128,9 @@ import Wasp.Analyzer.AnalyzeError
   )
 import Wasp.Analyzer.Evaluator (Decl, evaluate, takeDecls)
 import Wasp.Analyzer.Parser (parseStatements)
+import qualified Wasp.Analyzer.Parser as Parser
 import Wasp.Analyzer.Parser.Valid (validateAst)
-import Wasp.Analyzer.Prisma (injectEntitiesFromPrismaSchema)
+import Wasp.Analyzer.Prisma (injectEntitiesFromPrismaSchema, parseEntityStatements)
 import Wasp.Analyzer.StdTypeDefinitions (stdTypes)
 import Wasp.Analyzer.TypeChecker (typeCheck)
 import qualified Wasp.Psl.Ast.Schema as Psl.Schema
@@ -157,7 +159,17 @@ analyze prismaSchemaAst =
           ^ disallow entities here
                                                         ^ inject entities here
     --}
-    >=> (left ((: []) . ValidationError) . validateAst)
+    >=> wrapAnalyzerError ValidationError . validateAst
     >=> injectEntitiesFromPrismaSchema prismaSchemaAst
-    >=> (left ((: []) . TypeError) . typeCheck stdTypes)
-    >=> (left ((: []) . EvaluationError) . evaluate stdTypes)
+    >=> (wrapAnalyzerError TypeError . typeCheck stdTypes)
+    >=> (wrapAnalyzerError EvaluationError . evaluate stdTypes)
+
+getEntityDecls :: Psl.Schema.Schema -> Either [AnalyzeError] [Decl]
+getEntityDecls schema =
+  wrapAnalyzerError TypeError (typeCheck stdTypes astWithEntitiesOnly)
+    >>= (wrapAnalyzerError EvaluationError . evaluate stdTypes)
+  where
+    astWithEntitiesOnly = Parser.AST $ parseEntityStatements schema
+
+wrapAnalyzerError :: (e -> AnalyzeError) -> Either e a -> Either [AnalyzeError] a
+wrapAnalyzerError makeError = left ((: []) . makeError)

waspc/src/Wasp/Analyzer/Evaluator/Evaluation/TypedExpr/Combinators.hs

@@ -156,33 +156,18 @@ tuple4 eval1 eval2 eval3 eval4 = evaluation $ \(typeDefs, bindings) -> withCtx $
 extImport :: TypedExprEvaluation AppSpec.ExtImport.ExtImport
 extImport = evaluation' . withCtx $ \ctx -> \case
   TypedAST.ExtImport name extImportPath ->
+    -- NOTE(martin): This parsing here could instead be done in Parser.
     -- NOTE(martin): This parsing here could instead be done in Parser.
     --   I don't have a very good reason for doing it here instead of Parser, except
     --   for being somewhat simpler to implement.
     --   So we might want to move it to Parser at some point in the future, if we
     --   figure out that is better (it sounds/feels like it could be).
-    case stripImportPrefix extImportPath of
-      Just relFileFP -> case SP.parseRelFileP relFileFP of
-        Left err -> mkParseError ctx $ show err
-        Right relFileSP -> pure $ AppSpec.ExtImport.ExtImport name relFileSP
-      Nothing ->
-        mkParseError
-          ctx
-          $ "Path in external import must start with \"" ++ extSrcPrefix ++ "\"!"
+    case AppSpec.ExtImport.parseExtImportPath extImportPath of
+      Left err -> mkParseError ctx err
+      Right importPath -> pure $ AppSpec.ExtImport.ExtImport name importPath
   expr -> Left $ ER.mkEvaluationError ctx $ ER.ExpectedType T.ExtImportType (TypedAST.exprType expr)
   where
     mkParseError ctx msg = Left $ ER.mkEvaluationError ctx $ ER.ParseError $ ER.EvaluationParseError msg
-    stripImportPrefix importPath = stripPrefix extSrcPrefix importPath
-    -- Filip: We no longer want separation between client and server code
-    -- todo (filip): Do we still want to know whic is which. We might (because of the reloading).
-    -- For now, as we'd like (expect):
-    --   - Nodemon watches all files in the user's source folder (client files
-    --   included), but tsc only compiles the server files (I think because it
-    --   knows that the others aren't used). I am not yet sure how it knows this.
-    --   - Vite also only triggers on client files. I am not sure how it knows
-    --   about the difference either.
-    -- todo (filip): investigate
-    extSrcPrefix = "@src/"
 
 -- | An evaluation that expects a "JSON".
 json :: TypedExprEvaluation AppSpec.JSON.JSON

waspc/src/Wasp/Analyzer/Prisma.hs

@@ -1,5 +1,6 @@
 module Wasp.Analyzer.Prisma
   ( injectEntitiesFromPrismaSchema,
+    parseEntityStatements,
   )
 where
 
@@ -11,9 +12,12 @@ import qualified Wasp.Psl.Generator.Model as Psl.Model.Generator
 injectEntitiesFromPrismaSchema :: Psl.Schema.Schema -> Parser.AST -> Either a Parser.AST
 injectEntitiesFromPrismaSchema schema ast = Right $ ast {Parser.astStmts = stmts ++ entityStmts}
   where
-    entityStmts = makeEntityStmt <$> generatePrismaModelSources schema
+    entityStmts = parseEntityStatements schema
     stmts = Parser.astStmts ast
 
+parseEntityStatements :: Psl.Schema.Schema -> [WithCtx Parser.Stmt]
+parseEntityStatements schema = makeEntityStmt <$> generatePrismaModelSources schema
+
 type ModelName = String
 
 type ModelBody = String

waspc/src/Wasp/AppSpec/ExtImport.hs

@@ -6,14 +6,18 @@ module Wasp.AppSpec.ExtImport
   ( ExtImport (..),
     ExtImportName (..),
     importIdentifier,
+    parseExtImportPath,
   )
 where
 
+import Control.Arrow (left)
 import Data.Aeson (FromJSON (parseJSON), withObject, (.:))
 import Data.Aeson.Types (ToJSON)
 import Data.Data (Data)
+import Data.List (stripPrefix)
 import GHC.Generics (Generic)
-import StrongPath (File', Path, Posix, Rel, parseRelFileP)
+import StrongPath (File', Path, Posix, Rel)
+import qualified StrongPath as SP
 import Wasp.AppSpec.ExternalFiles (SourceExternalCodeDir)
 
 data ExtImport = ExtImport
@@ -30,18 +34,16 @@ instance FromJSON ExtImport where
     nameStr <- o .: "name"
     pathStr <- o .: "path"
     extImportName <- parseExtImportName kindStr nameStr
-    extImportPath <- parseExtImportPath pathStr
+    extImportPath <- case parseExtImportPath pathStr of
+      Right path' -> pure path'
+      Left err -> fail err
     return $ ExtImport extImportName extImportPath
     where
       parseExtImportName kindStr nameStr = case kindStr of
         "default" -> pure $ ExtImportModule nameStr
         "named" -> pure $ ExtImportField nameStr
         _ -> fail $ "Failed to parse import kind: " <> kindStr
 
-      parseExtImportPath pathStr = case parseRelFileP pathStr of
-        Just path' -> pure path'
-        Nothing -> fail $ "Failed to parse relative posix path to file: " <> pathStr
-
 type ExtImportPath = Path Posix (Rel SourceExternalCodeDir) File'
 
 type Identifier = String
@@ -57,3 +59,23 @@ importIdentifier :: ExtImport -> Identifier
 importIdentifier (ExtImport importName _) = case importName of
   ExtImportModule n -> n
   ExtImportField n -> n
+
+parseExtImportPath :: String -> Either String ExtImportPath
+parseExtImportPath extImportPath = case stripImportPrefix extImportPath of
+  Nothing -> Left $ "Path in external import must start with \"" ++ extSrcPrefix ++ "\"!"
+  Just relFileFP ->
+    left
+      (("Failed to parse relative posix path to file: " ++) . show)
+      $ SP.parseRelFileP relFileFP
+  where
+    stripImportPrefix importPath = stripPrefix extSrcPrefix importPath
+    -- Filip: We no longer want separation between client and server code
+    -- todo (filip): Do we still want to know which is which. We might (because of the reloading).
+    -- For now, as we'd like (expect):
+    --   - Nodemon watches all files in the user's source folder (client files
+    --   included), but tsc only compiles the server files (I think because it
+    --   knows that the others aren't used). I am not yet sure how it knows this.
+    --   - Vite also only triggers on client files. I am not sure how it knows
+    --   about the difference either.
+    -- todo (filip): investigate
+    extSrcPrefix = "@src/"

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