Userland files validation

[infomiho]

Closes #2169

Validates package.json

It loads the JSON and checks versions of deps: Wasp SDK, Prisma and React Router DOM.

Validates tsconfig.json

It loads the tsconfig.json which is JSON with comments (uses Node.js's eval to get proper JSON). It checks all the fields.

[Martinsos]

@infomiho looking good! I think all the big stuff is done, there is a couple of smaller things left that I commented on, but major stuff is good.

[Martinsos]

Let's maybe add type ErrorMsg = String here.

[Martinsos]

One thought on top of this: often, in our code, we just use Strings as error messages. General advice is that this is not good, you should use more structured types, but the truth is, for our needs this seems to be right at the moment.
However, it is still much nicer to see ErrorMsg in output type than String because it tells me what it is, which is why type ErrorMsg = String.
Now, sometimes it is nice to call it more specifically: type CompilerError = String, or type ParsingError = String, but in many parts of the code we don't want to bother iwth that and just doing type ErrorMsg = String is enough. But that means we have a lot of places where we do the same thing: define type ErrorMsg = String. So I wonder if we should just have central type ErrorMsg = String in some Wasp.Utils or something like that? We don't have to do this in this PR, but wanted to mention this now since I was talking about this. What do you think?

[infomiho]

I'll turn this line of thinking into an issue 👍

[infomiho]

#2310

[Martinsos]

I was looking at this call of validateToEither here to figure out if we might not need it, since it seemed to me it is oddly specific function and we could probably replace it with something nicer.

I was looking to do something like following instead:

ExceptT $ <sometransformation> $ validatePackageJson packageJson

So validatePackageJson packageJson gives us IO [String]. If this array is not empty , we want to shortcircuit the computation with this array sinced it is a list of errors. We could do this with following function:

\errors -> if null errors then Right () else Left errors

I guess we could name it like this:

errorsListToEither [] = Right ()
errorsListToEither _ = Left errors

And then we map it:

ExceptT $ errorsListToEither <$> validatePackageJson packageJson

actually, fmap it, since it doesn't operate in IO.

Although, I noticed in another comment that validatePackageJson packageJson doesn't even have to be IO, so that will also change things here, but I think the idea will remain the same.

Another approach which I have only a rough hint it might work but you can give it a try and see if it makes sense or not, buit I think ExceptT might be instance of ErrorMonad (or is it MonadError?), therefore supporting stuff like throw (or is it throw<something>?) and try or something like it. If that is so, you might be able to just do something like

case validatePackageJson packageJson of
  [] -> pure packageJson
  errors -> throwError errors

I assumed here that you made validatePackageJson to not be IO.

Although throwError here you could probably just replace with ExceptT . pure . Left, that is what it will be doing in the background I believe.

[infomiho]

I went with something super simple:

case validateTsConfig tsConfig of
  [] -> return tsConfig
  errors -> throwError errors

Thanks for the tip, it makes sense to inline it.

[Martinsos]

Ok perfect! I wrote a lot above in the comment in case train of thought is useful, but yeah this is the optimal solution at the end.

[Martinsos]

@infomiho I think this is it! Left couple of small comments but none require any changes I believe, give them a quick look and them merge when happy.

[Martinsos]

Nice catch :D!