@webda/create 0.0.0-stage → 4.0.0-beta.4

package/LICENSE

@@ -0,0 +1,166 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# @webda/create
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Create a [Webda](https://webda.io) v4 application, ready for coding agents.
+
+```bash
+npm create @webda my-app
+pnpm create @webda my-app --store postgres --transports rest,graphql --yes
+```
+
+| Flag                       | Values                                         | Default                                 |
+| -------------------------- | ---------------------------------------------- | --------------------------------------- |
+| `--store`                  | `memory`, `file`, `mongodb`, `postgres`        | `memory`                                |
+| `--transports`             | comma list of `rest`, `graphql`, `grpc`, `mcp` | `rest`                                  |
+| `--namespace`              | application namespace                          | from the directory name                 |
+| `--pm`                     | `pnpm`, `npm`, `yarn`                          | the package manager running the command |
+| `--no-install`, `--no-git` | skip install / git init                        |                                         |
+| `--yes`, `-y`              | accept defaults, never prompt                  |                                         |
+
+With `npm`, the generated app also gets a `.npmrc` setting `legacy-peer-deps=true`: npm 10 (bundled with Node 22) crashes
+on the optional peer dependencies of vitest/vite. It is safe to remove with npm >= 11.
+
+The generated app contains `AGENTS.md`, `CLAUDE.md` and skills in `.agents/skills/`.
+In an existing v4 project, Claude Code users can install the same skills:
+
+```text
+/plugin marketplace add loopingz/webda.io
+/plugin install webda@webda
+```

package/agent/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "webda",
+  "description": "Skills for building Webda v4 applications: models, services, operations, configuration, stores and tests",
+  "homepage": "https://webda.io",
+  "repository": "https://github.com/loopingz/webda.io",
+  "license": "LGPL-3.0-only"
+}

package/agent/AGENTS.md

@@ -0,0 +1,47 @@
+# __APP_NAME__
+
+A [Webda](https://webda.io) v4 application. Webda is a model-driven Node.js framework: you write models and services, and it exposes them through the configured transports (REST, GraphQL, gRPC, MCP) with validation and permissions.
+
+## Commands
+
+```bash
+npm run build   # compile src/ to lib/ and generate webda.module.json and .webda/
+npm run debug   # build, then start the dev server with the interactive debug console on http://localhost:18080
+npm run serve   # build, then start the HTTP server on http://localhost:18080 (no terminal UI)
+npm test        # build, then run the tests
+```
+
+## Layout
+
+- `src/models/*.model.ts`: domain models
+- `src/services/*.service.ts`: services
+- `test/`: tests
+- `webda.config.json`: services and parameters
+- `deployments/*.json`: per-environment overrides and deployers (when present)
+
+## Rules
+
+- Design the models first; put behaviour that is not about one model in a service.
+- Persist through the model: `Task.create({...})`, `Task.ref(uuid).get()`, `Task.query("done = false")`, or `useRepository(Task)`. Never inject or call a store.
+- Configuration belongs in `webda.config.json` and `deployments/`, not in code.
+- Never edit generated files: `.webda/`, `webda.module.json`, `lib/`.
+- After a change, run `npm run build` then `npm test`.
+- Agents and non-interactive shells: use `npm run serve`; `npm run debug` opens a fullscreen terminal UI.
+
+## This app
+
+<!-- WEBDA:APP -->
+
+## Skills
+
+Read the matching skill before working on a task:
+
+| Task                                                           | Skill                                         |
+| -------------------------------------------------------------- | --------------------------------------------- |
+| Add or change a model, its validation or relations             | `.agents/skills/webda-models/SKILL.md`        |
+| Add or change a service                                        | `.agents/skills/webda-services/SKILL.md`      |
+| Expose behaviour as an operation; REST, GraphQL, gRPC, MCP     | `.agents/skills/webda-operations/SKILL.md`    |
+| Configuration, parameters, deployment overrides                | `.agents/skills/webda-configuration/SKILL.md` |
+| Choose or switch the store; read and write data                | `.agents/skills/webda-stores/SKILL.md`        |
+| Write or fix tests                                             | `.agents/skills/webda-testing/SKILL.md`       |
+| Deploy, add an environment, build an image or a Lambda package | `.agents/skills/webda-deploy/SKILL.md`        |

package/agent/CLAUDE.md

@@ -0,0 +1,3 @@
+@AGENTS.md
+
+Skills for this project are in `.agents/skills/`: read the `SKILL.md` matching your task before changing code.

package/agent/skills/webda-configuration/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: webda-configuration
+description: Use when changing webda.config.json, application parameters, the parameters of a service or the per-environment deployments of a Webda app
+---
+
+# Webda configuration
+
+## When to use
+
+Enabling or configuring a service, setting application parameters or overriding them per environment.
+
+## Pattern
+
+`webda.config.json` declares the services and their parameters. `npm run build` generates `.webda/config.schema.json`, referenced by `$schema`, so editors validate the file.
+
+```json
+{
+  "$schema": ".webda/config.schema.json",
+  "version": 4,
+  "parameters": {
+    "supportEmail": "support@example.com"
+  },
+  "services": {
+    "HttpServer": { "type": "Webda/HttpServer" },
+    "ReminderService": { "type": "ReminderService", "delayHours": 12 }
+  }
+}
+```
+
+- `type` is `Namespace/Name`; types of your app can omit the namespace.
+- `parameters` are shared by every service; a few keys are framework settings (`website`, `static`, `apiUrl`, `metrics`), any other key is yours.
+- Values are not interpolated: `${VAR}` stays a literal string. Secrets come from the environment variables each service reads (for example `WEBDA_MONGO_URL`, `PGHOST`), never from the file.
+- `deployments/<name>.json` overrides `parameters` and `services` for one environment. Select it with `-d <name>` before the command name (`npx webda -d production serve`; after the command it is ignored), `--deployment <name>` (`npm run serve -- --deployment production`) or `WEBDA_DEPLOYMENT=production npm run serve`. Objects are deep merged over `webda.config.json` and arrays are replaced. Its `units` (deployers) are covered by webda-deploy.
+
+Read the configuration in code through the service parameters (`this.parameters.delayHours`) or the application parameters:
+
+```ts
+import { useParameters } from "@webda/core";
+
+export function supportEmail(): string {
+  return useParameters().supportEmail;
+}
+```
+
+## Common mistakes
+
+```text
+"mongoUrl": "${MONGO_URL}"             → not interpolated; use the service's environment variable
+Secrets committed in webda.config.json  → environment variables, documented in .env.example
+Editing .webda/config.schema.json       → generated by npm run build
+```
+
+## Verify
+
+`npm run build` (schema), then `npm run debug`: an unknown service type or a service that fails to create or init is logged as ERROR with the service name, and startup continues: read the logs.
+
+## Reference
+
+https://docs.webda.io
+
+Written for Webda 4.0.0-beta.

package/agent/skills/webda-deploy/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: webda-deploy
+description: Use when deploying a Webda app, adding a deployment environment or building a container image or Lambda package
+---
+
+# Webda deploy
+
+## When to use
+
+Adding an environment (`deployments/<name>.json`), building and pushing an OCI image, packaging the app for AWS Lambda or deploying it with CloudFormation.
+
+## Pattern
+
+Install the deployer package, then build: a generated app does not depend on any deployer, and the deployer types and commands are only discovered from the installed packages.
+
+```bash
+npm install @webda/oci   # Webda/ContainerDeployer
+npm install @webda/aws   # Webda/LambdaPackager, Webda/CloudFormationDeployer
+npm run build            # also before every deployer command: lib/ and webda.module.json get packaged
+```
+
+A deployment is a file `deployments/<name>.json` (`.jsonc`, `.yaml` and `.yml` work too). It has four sections:
+
+- `parameters` and `services` override `webda.config.json` (objects deep merged, arrays replaced; see webda-configuration).
+- `units` lists the deployers: each unit has a `name`, a `type` and the deployer parameters.
+- `resources` holds parameters shared by every unit; a unit overrides them.
+
+```json
+{
+  "$schema": "../.webda/deployment.schema.json",
+  "parameters": {
+    "supportEmail": "support@example.com"
+  },
+  "services": {
+    "ReminderService": { "delayHours": 48 }
+  },
+  "units": [
+    {
+      "name": "image",
+      "type": "Webda/ContainerDeployer",
+      "image": "ghcr.io/my-org/my-app",
+      "tags": ["${package.version}", "latest"],
+      "credentials": {
+        "ghcr.io": { "username": "${env.GHCR_USER}", "password": "${env.GHCR_TOKEN}" }
+      }
+    }
+  ]
+}
+```
+
+Select the deployment with `-d <name>` placed before the command name (after it, `-d` is silently ignored), `--deployment <name>` anywhere, or the `WEBDA_DEPLOYMENT` environment variable. `webda` is not on the PATH of a generated app: use `npx webda` (or `npm exec -- webda`). The same selection applies to `serve` and `debug`: they run the app with the overrides of that deployment.
+
+```bash
+npx webda -d production container build   # OCI layout in .webda/oci/<unit>, base layers included
+npx webda -d production container push    # build and push every tag of the unit
+npx webda -d production aws package       # Lambda zip (LambdaPackager unit), dist/lambda-<version>.zip by default
+npx webda -d production deploy            # run `deploy` of every unit that has it (ContainerDeployer, CloudFormationDeployer)
+npx webda -d production --service image container push   # only the unit named image
+WEBDA_DEPLOYMENT=production npm run serve         # npm scripts: environment variable
+npm run serve -- --deployment production         # or --deployment, never -d after the command
+```
+
+Units of other types in the same deployment:
+
+```json
+{
+  "units": [
+    { "name": "package", "type": "Webda/LambdaPackager", "zipPath": "dist/app.zip" },
+    {
+      "name": "stack",
+      "type": "Webda/CloudFormationDeployer",
+      "AssetsBucket": "my-artifacts",
+      "Lambda": {},
+      "APIGateway": {}
+    }
+  ]
+}
+```
+
+`Webda/LambdaPackager` is independent from `Webda/CloudFormationDeployer`: the latter packages its own Lambda from its `LambdaPackager` parameter.
+
+Units are not services of the app: a unit is only instantiated by a command its type provides, `serve` and `debug` never create it. `${...}` templates in unit parameters (`${package.version}`, `${git.commit}`, `${deployment}`, `${env.NAME}`) are replaced when the command runs.
+
+## Common mistakes
+
+```text
+Deployer config in "services"                → it goes in "units"; "services" only overrides app services
+A unit named like an app service             → DEPLOYMENT_UNIT_CONFLICT, rename the unit
+Running a deployer command without -d        → DEPLOYMENT_REQUIRED: select the deployment
+-d after the command name                    → ignored silently; put it before, or use --deployment
+Deployer package not installed               → unit of an unknown type is skipped silently, no command: npm install @webda/oci or @webda/aws, npm run build
+Secrets in deployments/*.json                → "${env.NAME}" in a unit parameter; parameters/services values are not interpolated, service secrets come from the environment variables the service reads
+```
+
+## Verify
+
+`npx webda -d production container build` logs `Built sha256:... in <path>` (it downloads the base image layers once, so it needs network access). `npx webda --help` lists the commands of the installed deployers (`@webda/oci`, `@webda/aws`).
+
+## Reference
+
+https://docs.webda.io
+
+Written for Webda 4.0.0-beta.

package/agent/skills/webda-models/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: webda-models
+description: Use when adding or changing a Webda model, its fields, validation, primary key or relations to other models
+---
+
+# Webda models
+
+## When to use
+
+Adding a model, adding or changing a field, its validation, the primary key, or a relation between models.
+
+## Pattern
+
+A model is a class in `src/models/<Name>.model.ts` extending `UuidModel` (generated `uuid` key) or `Model` (your own key). Fields are class properties; validation comes from JSDoc tags, which the compiler turns into the JSON schema. Run `npm run build` after changing a model: it regenerates `webda.module.json` and `.webda/`.
+
+```ts
+import { BelongTo, Model, OneToMany, UuidModel, WEBDA_PRIMARY_KEY } from "@webda/models";
+
+/**
+ * A product category, identified by its slug
+ */
+export class Category extends Model {
+  [WEBDA_PRIMARY_KEY] = ["slug"] as const;
+
+  /**
+   * URL-friendly identifier
+   * @pattern ^[a-z0-9-]+$
+   */
+  slug!: string;
+
+  /**
+   * @minLength 2
+   * @maxLength 50
+   */
+  name!: string;
+
+  products!: OneToMany<Product, Category, "category">;
+}
+
+/**
+ * A product of a category
+ */
+export class Product extends UuidModel {
+  /**
+   * @minLength 1
+   */
+  title!: string;
+
+  /**
+   * @minimum 0
+   */
+  price!: number;
+
+  /**
+   * Optional fields use `?`
+   * @maxLength 500
+   */
+  description?: string;
+
+  /**
+   * Category the product belongs to
+   */
+  category!: BelongTo<Category>;
+}
+```
+
+Relations:
+
+| Type                                       | Meaning                                                                                              |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| `BelongTo<Parent>`                         | this model belongs to a parent; deleting the parent does not delete it, delete the children yourself |
+| `RelateTo<Other>`                          | a link to another model, no cascade                                                                  |
+| `OneToMany<Child, ThisModel, "attribute">` | the children whose `attribute` points to this model (read side of `BelongTo`/`RelateTo`)             |
+| `ManyToMany<Other>`                        | many-to-many links                                                                                   |
+
+A `BelongTo` or `RelateTo` field is stored as the key of the target: pass the key of the parent, `parent.getUUID()` for a model with a `uuid` key.
+
+```ts
+import { BelongTo, UuidModel } from "@webda/models";
+
+export class Shelf extends UuidModel {
+  name!: string;
+}
+
+export class Book extends UuidModel {
+  title!: string;
+  shelf!: BelongTo<Shelf>;
+}
+
+export async function addBook(shelf: Shelf): Promise<Book> {
+  return Book.create({ title: "Dune", shelf: shelf.getUUID() });
+}
+```
+
+The `OneToMany` side is queried like a model, restricted to the children of that instance:
+
+```ts
+import { BelongTo, OneToMany, UuidModel } from "@webda/models";
+
+export class Author extends UuidModel {
+  name!: string;
+  articles!: OneToMany<Article, Author, "author">;
+}
+
+export class Article extends UuidModel {
+  title!: string;
+  author!: BelongTo<Author>;
+}
+
+export async function articleTitles(author: Author): Promise<string[]> {
+  const { results } = await author.articles.query("title != ? ORDER BY title LIMIT 20", [""]);
+  return results.map(article => article.title);
+}
+```
+
+Read and write data through the model (see the `webda-stores` skill): `Product.create({...})`, `Product.ref(uuid).get()`, `Product.query("price > 10")`.
+
+## Common mistakes
+
+```text
+@Model() / @Expose() decorators and CoreModel  → v3 APIs: extend Model or UuidModel, no decorators
+@Inject("productStore") store: Store           → never use a store directly: Product.create / Product.query
+Editing webda.module.json or .webda/           → generated: change the model and run npm run build
+```
+
+- Name model files `*.model.ts` (the build fails on a model file without that suffix); `src/models/` is the convention.
+- Import related models with `import type` to avoid circular imports.
+
+## Verify
+
+`npm run build` must succeed (it reports invalid JSDoc tags and relation targets), then `npm test`.
+
+## Reference
+
+https://docs.webda.io
+
+Written for Webda 4.0.0-beta.

package/agent/skills/webda-operations/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: webda-operations
+description: Use when exposing behaviour to clients as an operation, or enabling REST, GraphQL, gRPC or MCP in a Webda app
+---
+
+# Webda operations and transports
+
+## When to use
+
+Making a model or service method callable by clients, or adding a transport.
+
+## Pattern
+
+`@Operation()` on a service or model method declares an operation. Every enabled transport exposes it: REST, GraphQL, gRPC and MCP read the same operations, with the same input validation (from the TypeScript signature) and permissions. Models also get create/get/update/patch/delete/query operations automatically. The operation id of a service method is the service's configured name in `webda.config.json`, capitalized, then the capitalized method name: `GreetingService.Greet` when configured as `"GreetingService"`.
+
+```ts
+import { Operation, Service } from "@webda/core";
+
+/**
+ * @WebdaModda
+ */
+export class GreetingService extends Service {
+  /**
+   * Operation id: GreetingService.Greet; REST: PUT /greetingservice/greet
+   * @param name - who to greet
+   * @returns the greeting
+   */
+  @Operation()
+  greet(name: string): string {
+    return `Hello ${name}`;
+  }
+}
+```
+
+On a model, an instance method operation receives the model loaded from its key:
+
+```ts
+import { Operation } from "@webda/core";
+import { UuidModel } from "@webda/models";
+
+export class Invoice extends UuidModel {
+  paid!: boolean;
+
+  /**
+   * Operation id: Invoice.Pay
+   */
+  @Operation()
+  async pay(): Promise<void> {
+    this.paid = true;
+    await this.save();
+  }
+}
+```
+
+Transports are services in `webda.config.json`; add the package and the service:
+
+| Transport | Package          | Service                                                                                                                             |
+| --------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| REST      | `@webda/core`    | `"RESTService": { "type": "Webda/RESTOperationsTransport" }`                                                                        |
+| GraphQL   | `@webda/graphql` | `"GraphQLService": { "type": "Webda/GraphQLService" }`                                                                              |
+| gRPC      | `@webda/grpc`    | `"GRPCService": { "type": "Webda/GrpcService" }` plus `"HttpServerH2c": { "type": "Webda/HttpServer", "port": 50051, "h2c": true }` |
+| MCP       | `@webda/mcp`     | `"MCP": { "type": "Webda/McpService" }`                                                                                             |
+
+`Webda/DomainService` must stay configured: it registers the model operations.
+
+## Common mistakes
+
+```text
+Writing a REST route by hand for model CRUD  → already exposed by the model operations
+One method per transport                     → one @Operation serves every transport
+Removing DomainService                       → model operations disappear
+```
+
+## Verify
+
+`npm run build` regenerates `.webda/operations.json`: check your operation id is listed. Then `npm run debug` and call it.
+
+## Reference
+
+https://docs.webda.io
+
+Written for Webda 4.0.0-beta.