swagger-petstore VS yesod-persistent

Swagger offers more than just a user-friendly interface for exploring APIs. It also provides multiple generators that can produce code typically written by hand. As an Angular developer, this blog post will focus on the typescript-angular generator.

Failed to create a client for Java. The generator imports Java's types instead of TeamCity's. There are bugs described for the Java client in both the Swagger generator and the OpenAPI generator. Let's see how the generator behaves when building a Kotlin client.

[swagger-codegen](https://github.com/swagger-api/swagger-codegen) generates code from an OpenAPI definition, and it supports Rust code output (client and/or server).

Swagger contains three greats tools to work with the specification: Swagger UI, Swagger Editor and Swagger Codegen. The Swagger UI renders OpenAPI specs as interactive API documentation, Swagger Editor is a browser-based editor where you can write OpenAPI specs and Swagger Codegen generates server stubs and client libraries from an OpenAPI spec like the OpenAPI generator.

We ran into some minor issues (#1201, #1210, #1355, #1356 and #1769) and fixed some stuff we stumbled upon along the way, although it didn't really bother us as well (#1451 and #1769).

I am interested in integrating a swagger-codegen generated Python server with an existing Flask application. swagger-codegen generates a Python implementation based on the Connexion library from a Swagger API specification.

The method takes a query, String, and a completion block, (Result<[String], Error>) -> Void, which is triggered once the request finishes. Its internal implementation doesn't really matter since it could be from an external framework or generated by a code generator from the API specification.

The Java codegen options are here: https://github.com/swagger-api/swagger-codegen/issues/7795 (believe it or not).

Creating TS types/interfaces manually can be tedious. But, if you have JSON responses of your APIs, you can quickly convert those JSON responses to TS interfaces using VS Code extension Paste JSON as Code. Also, if your backend already uses Swagger for API, you can auto-generate all the TS types of your API models using swagger-codegen

I also looked into Snap (http://snapframework.com/) and Yesod (https://www.yesodweb.com/) for Haskell. I didn't really get anywhere with those though because I had build issues with dependencies and was in a bit of a hurry so I put them off for later.

If you have a yesod app and want to try this out, I've got a cabal.project that works for yesod and persistent: https://github.com/yesodweb/yesod/pull/1769

It would be an unorthodox choice. If you're looking to use this personal site as a portfolio project, you'd probably be better off using something like Node (JS), Java, or Python which tend to be a bit more marketable. However, if you want to try learning Haskell, then building a personal site with it seems like a great way to dive in. If you want to learn a bit more, Yesod seems to be the most well-documented Haskell web framework

I believe yesod is the go-to all encompassing framework.

frameworks like yesod and IHP

In this blog post I’m presenting an implementation of a Wiki System in the spirit of the legendary C2-Wiki - written in Haskell with the Yesod framework.

I'm wondering if this is related to this.

> Every language phasing the web is stringly typed

Heh, not even close. Off the top of my head I can think of Ur/Web as an extreme example ( http://www.impredicative.com/ur ), and slightly more mainstream systems like Yesod ( https://www.yesodweb.com ). I've worked professionally with Haskell, although not for Web stuff. These days I mostly work with Scala, which has a similar typing mindset to ML/Haskell, but unfortunately inherits a lot of stringly typed legacy from Java. We use an in-house library that provides zero-cost newtypes to distinguish between different semantically-distinct data types, many of which just-so-happen to be representable as subsets of String (e.g. GET parameter names, GET parameter values, POST bodies, etc.). This makes it a type error to try and e.g. concatenate different sorts of data together.

W.r.t. "escaping", I tend to avoid it entirely since it's inherently unsafe:

- "Escaping" doesn't distinguish between its input and output types; they're both just "String", and we have to make assumptions about the contents of each (i.e. it's unsafe)

- Having the same input and output types makes it possible to "double-escape" by accident. This discourages the use of escaping, just-in-case it happens to be done elsewhere; hence it's very common to end up without any escaping taking place.

- Having the same input and output types makes escaping functionally unnecessary: anything we do to an escaped string could also be done to an unescaped string, so it's up to us to remember that it's needed (i.e. it's unsafe).

The whole idea of "escaping a string" betrays a flawed approach to the problem. Instead of throwing everything into the same representation, then manually trying to figure out whether or not a value comes from a particular subset of that representation or not, it's much easier and safer to avoid lumping them all together in the first place. If our inputs have a certain type (e.g. HTTP.Get.Val) and we can only output certain other types (e.g. JSON, Map[HTTP.Header.Key, HTTP.Header.Val], etc.), then the processing which turns input into output is forced to specify any necessary conversions. Whilst such conversions may involve escape sequences, having them associated to particular types is more akin to serialisation.

Heck, at my first PHP job we largely solved this problem not by 'filtering and escaping', but by modifying the PHP interpreter to distinguish between 'clean' and 'dirty' strings (with literals being clean, and $_GET, etc. being dirty). Operations like concatenation would propagate 'dirtiness', and output functions like 'echo' would crash if given a dirty string. Traditional 'escaping' functions would convert dirty strings to clean ones, and crash when given a clean string. Having this be dynamic was more annoying than ahead-of-time compile errors, but it still did a pretty good job.

There's pretty much no excuse for stringly typed languages/libraries/etc. when such such trivial solutions exist, other than the historical inertia of legacy systems.

The project is going to make use of Warp. To smoothen the development process I set up yesod-bin according to their template for non-yesod projects. This worked fine initially, giving me hot reloading on file changes, but after adding the private package as described above it's giving the following error: