Bringing Prisma entities to the frontend

waspc/ChangeLog.md

@@ -5,15 +5,44 @@
 ### `wasp deploy` CLI command added
 We have made it much easier to deploy your Wasp apps via a new CLI command, `wasp deploy`. 🚀 This release adds support for Fly.io, but we hope to add more hosting providers soon!
 
-### Import Wasp entity types on the backend
-You can now import and use the types of Wasp entities in your backend code:
+### Import Wasp entity types (on frontend and backend)
+You can now import and use the types of Wasp entities anywhere in your code.
+
+Let's assume your Wasp file contains the following entity:
+```c
+entity Task {=psl
+    id          Int     @id @default(autoincrement())
+    description String
+    isDone      Boolean @default(false)
+    user        User    @relation(fields: [userId], references: [id])
+    userId      Int
+psl=}
+```
+Here's how a file on your backend can use it:
 ```typescript
 import { Task } from '@wasp/entities/Task'
 
-const getTasks = (args, context): Task[] => {
+const getTasks = (args, context) => {
     const tasks: Task[] = // ...
     // ...
 }
+```
+And here's how a frontend component can use it:
+
+```typescript
+// ...
+import { useQuery } from '@wasp/queries'
+import getTasks from '@wasp/queries/getTasks.js'
+import { Task } from '@wasp/entities'
+
+type TaskPayload = Pick<Task, "id">
+
+const Todo = (props: any) => {
+  // The variable 'task' will now have the type Task.
+  const { data: task } = useQuery<TaskPayload, Task>(getTask, { id: taskId })
+  // ...
+}
+
 ```
 
 ### TypeScript support for Queries and Actions

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

@@ -7,7 +7,7 @@ import Control.Monad.Except (throwError)
 import Control.Monad.IO.Class (liftIO)
 import Data.List (intercalate)
 import Path.IO (copyDirRecur, doesDirExist)
-import StrongPath (Abs, Dir, Path, Path', System, fromAbsFile, parseAbsDir, reldir, relfile, (</>))
+import StrongPath (Abs, Dir, Path, Path', System, parseAbsDir, reldir, relfile, (</>))
 import StrongPath.Path (toPathAbsDir)
 import System.Directory (getCurrentDirectory)
 import qualified System.FilePath as FP
@@ -18,6 +18,7 @@ import Wasp.Common (WaspProjectDir)
 import qualified Wasp.Common as Common (WaspProjectDir)
 import qualified Wasp.Data as Data
 import Wasp.Util (indent, kebabToCamelCase)
+import qualified Wasp.Util.IO as IOUtil
 import qualified Wasp.Util.Terminal as Term
 import qualified Wasp.Version as WV
 
@@ -85,9 +86,9 @@ initializeProjectFromSkeleton absWaspProjectDir = do
   copyDirRecur (toPathAbsDir absSkeletonDir) (toPathAbsDir absWaspProjectDir)
 
 writeMainWaspFile :: Path System Abs (Dir WaspProjectDir) -> ProjectInfo -> IO ()
-writeMainWaspFile waspProjectDir (ProjectInfo projectName appName) = writeFile absMainWaspFile mainWaspFileContent
+writeMainWaspFile waspProjectDir (ProjectInfo projectName appName) = IOUtil.writeFile absMainWaspFile mainWaspFileContent
   where
-    absMainWaspFile = fromAbsFile $ waspProjectDir </> [relfile|main.wasp|]
+    absMainWaspFile = waspProjectDir </> [relfile|main.wasp|]
     mainWaspFileContent =
       unlines
         [ "app %s {" `printf` appName,

waspc/cli/src/Wasp/Cli/Command/Db/Migrate.hs

@@ -4,18 +4,18 @@ module Wasp.Cli.Command.Db.Migrate
   )
 where
 
-import Control.Monad.Except (throwError)
+import Control.Monad.Except (ExceptT (ExceptT), liftEither, runExceptT, throwError)
 import Control.Monad.IO.Class (liftIO)
--- Wasp generator interface.
-
-import StrongPath ((</>))
+import StrongPath (Abs, Dir, Path', (</>))
 import Wasp.Cli.Command (Command, CommandError (..))
 import Wasp.Cli.Command.Common
   ( findWaspProjectRootDirFromCwd,
   )
 import Wasp.Cli.Command.Message (cliSendMessageC)
 import qualified Wasp.Cli.Common as Cli.Common
+import Wasp.Common (DbMigrationsDir)
 import qualified Wasp.Common
+import Wasp.Generator.Common (ProjectRootDir)
 import Wasp.Generator.DbGenerator.Common (MigrateArgs (..), defaultMigrateArgs)
 import qualified Wasp.Generator.DbGenerator.Operations as DbOps
 import qualified Wasp.Message as Msg
@@ -26,26 +26,33 @@ import qualified Wasp.Message as Msg
 migrateDev :: [String] -> Command ()
 migrateDev optionalMigrateArgs = do
   waspProjectDir <- findWaspProjectRootDirFromCwd
-  let genProjectRootDir =
+  let waspDbMigrationsDir = waspProjectDir </> Wasp.Common.dbMigrationsDirInWaspProjectDir
+  let projectRootDir =
         waspProjectDir
           </> Cli.Common.dotWaspDirInWaspProjectDir
           </> Cli.Common.generatedCodeDirInDotWaspDir
 
-  let waspDbMigrationsDir =
-        waspProjectDir
-          </> Wasp.Common.dbMigrationsDirInWaspProjectDir
+  migrateDatabase optionalMigrateArgs projectRootDir waspDbMigrationsDir
+  generatePrismaClients projectRootDir
+
+migrateDatabase :: [String] -> Path' Abs (Dir ProjectRootDir) -> Path' Abs (Dir DbMigrationsDir) -> Command ()
+migrateDatabase optionalMigrateArgs projectRootDir dbMigrationsDir = do
+  cliSendMessageC $ Msg.Start "Starting database migration..."
+  liftIO tryMigrate >>= \case
+    Left err -> throwError $ CommandError "Migrate dev failed" err
+    Right () -> cliSendMessageC $ Msg.Success "Database successfully migrated."
+  where
+    tryMigrate = runExceptT $ do
+      migrateArgs <- liftEither $ parseMigrateArgs optionalMigrateArgs
+      ExceptT $ DbOps.migrateDevAndCopyToSource dbMigrationsDir projectRootDir migrateArgs
 
-  let parsedMigrateArgs = parseMigrateArgs optionalMigrateArgs
-  case parsedMigrateArgs of
-    Left parseError ->
-      throwError $ CommandError "Migrate dev failed" parseError
-    Right migrateArgs -> do
-      cliSendMessageC $ Msg.Start "Performing migration..."
-      migrateResult <- liftIO $ DbOps.migrateDevAndCopyToSource waspDbMigrationsDir genProjectRootDir migrateArgs
-      case migrateResult of
-        Left migrateError ->
-          throwError $ CommandError "Migrate dev failed" migrateError
-        Right () -> cliSendMessageC $ Msg.Success "Migration done."
+generatePrismaClients :: Path' Abs (Dir ProjectRootDir) -> Command ()
+generatePrismaClients projectRootDir = do
+  cliSendMessageC $ Msg.Start "Generating prisma clients..."
+  generatePrismaClientsResult <- liftIO $ DbOps.generatePrismaClients projectRootDir
+  case generatePrismaClientsResult of
+    Left err -> throwError $ CommandError "Could not generate Prisma clients" err
+    Right () -> cliSendMessageC $ Msg.Success "Prisma clients successfully generated."
 
 -- | Basic parsing of db-migrate args. In the future, we could use a smarter parser
 -- for this (and all other CLI arg parsing).

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

@@ -7,9 +7,9 @@ where
 
 import Control.Arrow
 import Control.Monad.Except
-import StrongPath (Abs, Dir, Path', fromAbsFile, fromRelFile, toFilePath)
+import StrongPath (Abs, Dir, Path', fromRelFile)
 import StrongPath.Operations
-import System.Directory (doesFileExist, getFileSize)
+import System.Directory (getFileSize)
 import qualified Wasp.Analyzer as Analyzer
 import qualified Wasp.AppSpec.App as AS.App
 import qualified Wasp.AppSpec.Core.Decl as AS (Decl, takeDecls)
@@ -22,7 +22,8 @@ import Wasp.Common (WaspProjectDir)
 import Wasp.Error (showCompilerErrorForTerminal)
 import Wasp.Lib (findWaspFile)
 import qualified Wasp.Message as Msg
-import Wasp.Util.IO (listDirectoryDeep)
+import Wasp.Util (ifM)
+import qualified Wasp.Util.IO as IOUtil
 import qualified Wasp.Util.Terminal as Term
 
 info :: Command ()
@@ -48,24 +49,26 @@ printInfo :: String -> String -> String
 printInfo key value = Term.applyStyles [Term.Cyan] key ++ ": " <> Term.applyStyles [Term.White] value
 
 readDirectorySizeMB :: Path' Abs (Dir WaspProjectDir) -> IO String
-readDirectorySizeMB path = (++ " MB") . show . (`div` 1000000) . sum <$> (listDirectoryDeep path >>= mapM (getFileSize . fromRelFile))
+readDirectorySizeMB path = (++ " MB") . show . (`div` 1000000) . sum <$> allFileSizes
+  where
+    allFileSizes = IOUtil.listDirectoryDeep path >>= mapM (getFileSize . fromRelFile)
 
 readCompileInformation :: Path' Abs (Dir WaspProjectDir) -> IO String
-readCompileInformation waspDir = do
-  let dotWaspInfoFile =
-        fromAbsFile $
-          waspDir </> Cli.Common.dotWaspDirInWaspProjectDir
-            </> Cli.Common.generatedCodeDirInDotWaspDir
-            </> Cli.Common.dotWaspInfoFileInGeneratedCodeDir
-  dotWaspInfoFileExists <- doesFileExist dotWaspInfoFile
-  if dotWaspInfoFileExists
-    then do readFile dotWaspInfoFile
-    else return "No compile information found"
+readCompileInformation waspDir =
+  ifM
+    (IOUtil.doesFileExist dotWaspInfoFile)
+    (IOUtil.readFile dotWaspInfoFile)
+    (return "No compile information found")
+  where
+    dotWaspInfoFile =
+      waspDir </> Cli.Common.dotWaspDirInWaspProjectDir
+        </> Cli.Common.generatedCodeDirInDotWaspDir
+        </> Cli.Common.dotWaspInfoFileInGeneratedCodeDir
 
 parseWaspFile :: Path' Abs (Dir WaspProjectDir) -> IO (Either String [AS.Decl])
 parseWaspFile waspDir = runExceptT $ do
   waspFile <- ExceptT $ findWaspFile waspDir
-  waspStr <- liftIO $ readFile $ toFilePath waspFile
+  waspStr <- liftIO $ IOUtil.readFile waspFile
   liftEither $ left (annotateErrorForCli waspFile waspStr) $ Analyzer.analyze waspStr
   where
     annotateErrorForCli waspFile waspStr =

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

@@ -40,7 +40,7 @@ telemetry = do
 
     maybeProjectHash <- (Just <$> TlmProject.getWaspProjectPathHash) `catchError` const (return Nothing)
     for_ maybeProjectHash $ \projectHash -> do
-      maybeProjectCache <- liftIO $ TlmProject.readProjectTelemetryFile telemetryCacheDirPath projectHash
+      maybeProjectCache <- liftIO $ TlmProject.readProjectTelemetryCache telemetryCacheDirPath projectHash
       for_ maybeProjectCache $ \projectCache -> do
         let maybeTimeOfLastSending = TlmProject.getTimeOfLastTelemetryDataSent projectCache
         for_ maybeTimeOfLastSending $ \timeOfLastSending -> do

waspc/cli/src/Wasp/Cli/Command/Telemetry/Project.hs

@@ -3,7 +3,7 @@
 module Wasp.Cli.Command.Telemetry.Project
   ( getWaspProjectPathHash,
     considerSendingData,
-    readProjectTelemetryFile,
+    readProjectTelemetryCache,
     getTimeOfLastTelemetryDataSent,
     -- NOTE: for testing only
     checkIfEnvValueIsTruthy,
@@ -27,14 +27,15 @@ import qualified Network.HTTP.Simple as HTTP
 import Paths_waspc (version)
 import StrongPath (Abs, Dir, File', Path')
 import qualified StrongPath as SP
-import qualified System.Directory as SD
 import qualified System.Environment as ENV
 import qualified System.Info
 import Wasp.Cli.Command (Command)
 import qualified Wasp.Cli.Command.Call as Command.Call
 import Wasp.Cli.Command.Common (findWaspProjectRootDirFromCwd)
 import Wasp.Cli.Command.Telemetry.Common (TelemetryCacheDir)
 import Wasp.Cli.Command.Telemetry.User (UserSignature (..))
+import Wasp.Util (ifM)
+import qualified Wasp.Util.IO as IOUtil
 
 considerSendingData :: Path' Abs (Dir TelemetryCacheDir) -> UserSignature -> ProjectHash -> Command.Call.Call -> IO ()
 considerSendingData telemetryCacheDirPath userSignature projectHash cmdCall = do
@@ -125,26 +126,28 @@ initialCache = ProjectTelemetryCache {_lastCheckIn = Nothing, _lastCheckInBuild
 getTimeOfLastTelemetryDataSent :: ProjectTelemetryCache -> Maybe T.UTCTime
 getTimeOfLastTelemetryDataSent cache = maximum [_lastCheckIn cache, _lastCheckInBuild cache]
 
-readProjectTelemetryFile :: Path' Abs (Dir TelemetryCacheDir) -> ProjectHash -> IO (Maybe ProjectTelemetryCache)
-readProjectTelemetryFile telemetryCacheDirPath projectHash = do
-  fileExists <- SD.doesFileExist filePathFP
-  if fileExists then readCacheFile else return Nothing
+readProjectTelemetryCache :: Path' Abs (Dir TelemetryCacheDir) -> ProjectHash -> IO (Maybe ProjectTelemetryCache)
+readProjectTelemetryCache telemetryCacheDirPath projectHash =
+  ifM
+    (IOUtil.doesFileExist projectTelemetryFile)
+    parseProjectTelemetryFile
+    (return Nothing)
   where
-    filePathFP = SP.fromAbsFile $ getProjectTelemetryFilePath telemetryCacheDirPath projectHash
-    readCacheFile = Aeson.decode . ByteStringLazyUTF8.fromString <$> readFile filePathFP
+    projectTelemetryFile = getProjectTelemetryFilePath telemetryCacheDirPath projectHash
+    parseProjectTelemetryFile = Aeson.decode . ByteStringLazyUTF8.fromString <$> IOUtil.readFile projectTelemetryFile
 
 readOrCreateProjectTelemetryFile :: Path' Abs (Dir TelemetryCacheDir) -> ProjectHash -> IO ProjectTelemetryCache
 readOrCreateProjectTelemetryFile telemetryCacheDirPath projectHash = do
-  maybeProjectTelemetryCache <- readProjectTelemetryFile telemetryCacheDirPath projectHash
+  maybeProjectTelemetryCache <- readProjectTelemetryCache telemetryCacheDirPath projectHash
   case maybeProjectTelemetryCache of
     Just cache -> return cache
     Nothing -> writeProjectTelemetryFile telemetryCacheDirPath projectHash initialCache >> return initialCache
 
 writeProjectTelemetryFile :: Path' Abs (Dir TelemetryCacheDir) -> ProjectHash -> ProjectTelemetryCache -> IO ()
 writeProjectTelemetryFile telemetryCacheDirPath projectHash cache = do
-  writeFile filePathFP (ByteStringLazyUTF8.toString $ Aeson.encode cache)
+  IOUtil.writeFile projectTelemetryFile (ByteStringLazyUTF8.toString $ Aeson.encode cache)
   where
-    filePathFP = SP.fromAbsFile $ getProjectTelemetryFilePath telemetryCacheDirPath projectHash
+    projectTelemetryFile = getProjectTelemetryFilePath telemetryCacheDirPath projectHash
 
 getProjectTelemetryFilePath :: Path' Abs (Dir TelemetryCacheDir) -> ProjectHash -> Path' Abs File'
 getProjectTelemetryFilePath telemetryCacheDir (ProjectHash projectHash) =

waspc/cli/src/Wasp/Cli/Command/Telemetry/User.hs

@@ -9,10 +9,10 @@ where
 import qualified Data.UUID.V4 as UUID
 import StrongPath (Abs, Dir, File', Path', relfile)
 import qualified StrongPath as SP
-import qualified System.Directory as SD
 import qualified System.Environment as ENV
 import Wasp.Cli.Command.Telemetry.Common (TelemetryCacheDir)
-import Wasp.Util (checksumFromString, hexToString, orIfNothingM)
+import Wasp.Util (checksumFromString, hexToString, ifM, orIfNothingM)
+import qualified Wasp.Util.IO as IOUtil
 
 -- Random, non-identifyable UUID used to represent user in analytics.
 newtype UserSignature = UserSignature {_userSignatureValue :: String} deriving (Show)
@@ -22,17 +22,18 @@ obtainUserSignature telemetryCacheDirPath =
   getUserSignatureFromEnv `orIfNothingM` readOrCreateUserSignatureFile telemetryCacheDirPath
 
 readOrCreateUserSignatureFile :: Path' Abs (Dir TelemetryCacheDir) -> IO UserSignature
-readOrCreateUserSignatureFile telemetryCacheDirPath = do
-  let filePath = getUserSignatureFilePath telemetryCacheDirPath
-  let filePathFP = SP.fromAbsFile filePath
-  fileExists <- SD.doesFileExist filePathFP
+readOrCreateUserSignatureFile telemetryCacheDirPath =
   UserSignature
-    <$> if fileExists
-      then readFile filePathFP
-      else do
-        userSignature <- show <$> UUID.nextRandom
-        writeFile filePathFP userSignature
-        return userSignature
+    <$> ifM
+      (IOUtil.doesFileExist userSignatureFile)
+      (IOUtil.readFile userSignatureFile)
+      createUserSignatureFile
+  where
+    userSignatureFile = getUserSignatureFilePath telemetryCacheDirPath
+    createUserSignatureFile = do
+      userSignature <- show <$> UUID.nextRandom
+      IOUtil.writeFile userSignatureFile userSignature
+      return userSignature
 
 getUserSignatureFilePath :: Path' Abs (Dir TelemetryCacheDir) -> Path' Abs File'
 getUserSignatureFilePath telemetryCacheDir = telemetryCacheDir SP.</> [relfile|signature|]

waspc/data/Generator/templates/Dockerfile

@@ -33,7 +33,7 @@ COPY server/package*.json ./server/
 RUN cd server && npm install
 {=# usingPrisma =}
 COPY db/schema.prisma ./db/
-RUN cd server && npx prisma generate --schema=../db/schema.prisma
+RUN cd server && {= serverPrismaClientOutputDirEnv =} npx prisma generate --schema='{= dbSchemaFileFromServerDir =}'
 {=/ usingPrisma =}
 
 

waspc/data/Generator/templates/db/schema.prisma

@@ -7,8 +7,7 @@ datasource db {
 
 generator client {
   provider = "prisma-client-js"
-  {=! TODO(matija): this shouldn't be hardcoded, generator should provide this path. =}
-  output = "../server/node_modules/.prisma/client"
+  output = {=& prismaClientOutputDir =}
 }
 
 {=# modelSchemas =}

waspc/data/Generator/templates/react-app/src/actions/index.ts

@@ -14,14 +14,14 @@ export type Action<Input, Output> = (args?: Input) => Promise<Output>;
  * action with extra options.
  *
  */
-export type ActionOptions<ActionInput, CachedData> = {
-  optimisticUpdates: OptimisticUpdateDefinition<ActionInput, CachedData>[]
+export type ActionOptions<ActionInput> = {
+  optimisticUpdates: OptimisticUpdateDefinition<ActionInput, any>[]
 }
 
 /**
  * A documented (public) way to define optimistic updates.
  */
-export type OptimisticUpdateDefinition<ActionInput, CachedData = unknown> = {
+export type OptimisticUpdateDefinition<ActionInput, CachedData> = {
   getQuerySpecifier: GetQuerySpecifier<ActionInput, CachedData>
   updateQuery: UpdateQuery<ActionInput, CachedData>
 }
@@ -50,9 +50,9 @@ export type QuerySpecifier<Input, Output> = [Query<Input, Output>, ...any[]]
  * @param actionOptions An options object for enhancing/decorating the given Action.
  * @returns A decorated Action with added behavior but an unchanged API.
  */
-export function useAction<Input = unknown, Output = unknown, CachedData = unknown>(
+export function useAction<Input = unknown, Output = unknown>(
   actionFn: Action<Input, Output>,
-  actionOptions?: ActionOptions<Input, CachedData>
+  actionOptions?: ActionOptions<Input>
 ): typeof actionFn {
   const queryClient = useQueryClient();
 

waspc/data/Generator/templates/react-app/src/entities/index.ts

@@ -0,0 +1,18 @@
+{{={= =}=}}
+import {
+  {=# entities =}
+  {= name =},
+  {=/ entities =}
+} from '@prisma/client'
+
+export type {
+  {=# entities =}
+  {= name =},
+  {=/ entities =}
+} from '@prisma/client'
+
+export type WaspEntity = 
+  {=# entities =}
+  | {= name =}
+  {=/ entities =}
+  | never