Convert docs to mdbook project

Author: bikeshedder

.gitignore

@@ -0,0 +1 @@
+book

README.md

@@ -1,140 +1,11 @@
-# webwire
-
-![webwire logo](docs/logo.svg)
+![webwire logo](src/logo.svg)
 
 [![Discord Chat](https://img.shields.io/discord/726922033039933472?label=Discord+Chat&color=%23677bc4&logo=discord&logoColor=white&style=for-the-badge)](https://discord.gg/jjD6aWG)
 
 Webwire is a **contract-first API** system which features an
-[interface description language](docs/interface_description_language.md),
-a network [protocol](docs/protocol.md) and
-[code generator](docs/code_generator.md) for both servers and clients.
-
-## Resources
-
-- **Website:** https://webwire.dev/
-- **GitHub:** https://github.com/webwire/
-- **Discord:** https://discord.gg/jjD6aWG
-
-## WORK IN PROGRESS
-
-> **Webwire is not ready to use! All the documentation and code in this
-repository is either incomplete or non functional. Don't expect anything
-to work, yet. Right now this repository is just a collection of ideas and
-preliminary implementations.**
-
-## Example
-
-The following example assumes a Rust server and a TypeScript client. Webwire
-is by no means limited to those two but those languages show the potential of
-webwire best.
-
-Given the following IDL file:
-
-```webwire
-webwire 1.0;
-
-struct HelloRequest {
-    name: String,
-}
-
-struct HelloResponse {
-    message: String,
-}
-
-service Hello {
-    hello: HelloRequest -> HelloResponse
-}
-```
-
-The server and client files can be generated using the code generator:
-
-```bash
-$ webwire generate rust server api/hello.ww server/src/api.rs
-$ webwire generate ts client api/hello.ww client/src/api.ts
-```
-
-A Rust server implementation for the given code would look like this:
-
-```rust
-use std::net::SocketAddr;
-use webwire::{Context, Request, Response}
-use webwire::hyper::Server;
-
-mod api;
-use api::v1::{Hello, HelloRequest, HelloResponse}; // this is the generated code
-
-struct HelloService {}
-
-impl Hello for HelloService {
-    fn hello(&self, ctx: &Context, request: &HelloRequest) -> HelloResponse {
-        HelloResponse {
-            message: format!("Hello {}!", request.name)
-        }
-    }
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error> {
-    let addr = SocketAddr::from(([127, 0, 0, 1], 8000));
-    let service = HelloService {};
-    let server = webwire::Server::bind(addr).serve(service);
-    server.await
-}
-```
-
-A TypeScript client using the generated code would look like that:
-
-```typescript
-import { Client } from 'api/v1' // this is the generated code
-
-client = new Client('http://localhost:8000/')
-const response = await client.hello({ name: 'World' })
-assert(response.message === 'Hello World!')
-```
-
-## Building blocks
-
-- The [webwire interface description language](docs/interface_description_language.md)
-  describes service endpoints and how they are called.
-
-- The [webwire protocol](docs/protocol.md) is the actual representation
-  how data is transferred between client and server.
-
-- The [webwire code generator](docs/code_generator.md) uses the schema
-  language to generate client and server stubs.
-
-
-## Unique selling points
-
-- Webwire generates client and server code which is ready to run. The
-  generated code contains everything to make requests and
-
-- Webwire supports both **stateless unidirectional** communication and and
-  **stateful bidirectional** communication. This makes it a perfect fit for
-  application that require some kind of real-time update from the server
-  without the client having to poll for updates.
-
-- Webwire validates requests and responses. If data does not match the
-  given schema an error is raised an the data is not processed any
-  further.
-
-- Webwire is modelled after programming languages and not after a
-  serialization format. Therefore types like `UUID`, `Date` and `Time`
-  are part of the specification even if the used serialization format
-  does not support them. When using a serialization format which does
-  not support those types natively (e.g. JSON) they are encoded as
-  string. This is transparent to the users of webwire.
-
-- Webwire has a special type called `fieldset`. Fieldsets can be used to
-  construct a struct out of another struct by picking a subset of fields.
-  This is especially useful when designing APIs where multiple endpoints
-  use almost the same structure which just differs in a few fields.
-
-
-## Non goals
+[interface description language](/idl.md),
+a network [protocol](/protocol.md) and
+[code generator](/codegen.md) for both servers and clients.
 
-- Webwire can not be used to describe existing APIs. Webwire only makes
-  sense as a whole package. The IDL, protocol and code generator all make
-  a complete package and leaving out one or the other just doesn't make
-  any sense. If you need to document an existing API have a look at
-  [OpenAPI](https://swagger.io/docs/specification/about/).
+This repository contains the documentation sources used to generate
+the website at [https://webwire.dev/](https://webwire.dev/).

book.toml

@@ -0,0 +1,6 @@
+[book]
+authors = ["Michael P. Jung"]
+language = "en"
+multilingual = false
+src = "src"
+title = "Webwire"