feat(treewide): Add recipes and user handling

28 files changed, 1364 insertions, 110 deletions

diff --git a/crates/rocie-server/src/api/get/auth/mod.rs b/crates/rocie-server/src/api/get/auth/mod.rs
index c51f6a7..0821222 100644
--- a/crates/rocie-server/src/api/get/auth/mod.rs
+++ b/crates/rocie-server/src/api/get/auth/mod.rs
@@ -1,9 +1,12 @@
 use actix_web::web;
+use log::info;
+use percent_encoding::percent_decode_str;
 
 pub(crate) mod inventory;
 pub(crate) mod product;
 pub(crate) mod product_parent;
 pub(crate) mod recipe;
+pub(crate) mod recipe_parent;
 pub(crate) mod unit;
 pub(crate) mod unit_property;
 pub(crate) mod user;
@@ -17,11 +20,19 @@ pub(crate) fn register_paths(cfg: &mut web::ServiceConfig) {
         .service(product::products_by_product_parent_id_indirect)
         .service(product::products_in_storage)
         .service(product::products_registered)
+        .service(product::products_without_product_parent)
         .service(product_parent::product_parents)
         .service(product_parent::product_parents_toplevel)
         .service(product_parent::product_parents_under)
+        .service(recipe::recipe_by_name)
         .service(recipe::recipe_by_id)
         .service(recipe::recipes)
+        .service(recipe::recipes_by_recipe_parent_id_direct)
+        .service(recipe::recipes_by_recipe_parent_id_indirect)
+        .service(recipe::recipes_without_recipe_parent)
+        .service(recipe_parent::recipe_parents)
+        .service(recipe_parent::recipe_parents_toplevel)
+        .service(recipe_parent::recipe_parents_under)
         .service(unit::unit_by_id)
         .service(unit::units)
         .service(unit::units_by_property_id)
@@ -30,3 +41,20 @@ pub(crate) fn register_paths(cfg: &mut web::ServiceConfig) {
         .service(user::users)
         .service(user::user_by_id);
 }
+
+/// A String, that is not url-decoded on parse.
+struct UrlEncodedString(String);
+
+impl UrlEncodedString {
+    /// Percent de-encode a given string
+    fn percent_decode(&self) -> Result<String, std::str::Utf8Error> {
+        percent_decode_str(self.0.replace('+', "%20").as_str())
+            .decode_utf8()
+            .map(|s| s.to_string())
+            .inspect(|s| info!("Decoded `{}` as `{s}`", self.0))
+    }
+
+    fn from_str(inner: &str) -> Self {
+        Self(inner.to_owned())
+    }
+}
diff --git a/crates/rocie-server/src/api/get/auth/product.rs b/crates/rocie-server/src/api/get/auth/product.rs
index 1a1e31d..7e32a0b 100644
--- a/crates/rocie-server/src/api/get/auth/product.rs
+++ b/crates/rocie-server/src/api/get/auth/product.rs
@@ -1,33 +1,13 @@
 use actix_identity::Identity;
 use actix_web::{HttpRequest, HttpResponse, Responder, Result, get, web};
-use log::info;
-use percent_encoding::percent_decode_str;
 
 use crate::{
-    app::App,
-    storage::sql::{
+    api::get::auth::UrlEncodedString, app::App, storage::sql::{
         product::{Product, ProductId, ProductIdStub},
         product_amount::ProductAmount,
         product_parent::{ProductParent, ProductParentId, ProductParentIdStub},
-    },
-};
-
-/// A String, that is not url-decoded on parse.
-struct UrlEncodedString(String);
-
-impl UrlEncodedString {
-    /// Percent de-encode a given string
-    fn percent_decode(&self) -> Result<String, std::str::Utf8Error> {
-        percent_decode_str(self.0.replace('+', "%20").as_str())
-            .decode_utf8()
-            .map(|s| s.to_string())
-            .inspect(|s| info!("Decoded `{}` as `{s}`", self.0))
-    }
-
-    fn from_str(inner: &str) -> Self {
-        Self(inner.to_owned())
     }
-}
+};
 
 /// Get Product by id
 #[utoipa::path(
@@ -118,7 +98,7 @@ pub(crate) async fn product_by_name(
     );
     let name = name.percent_decode()?;
 
-    match Product::from_name(&app, name).await? {
+    match Product::from_name(&app, name.as_str()).await? {
         Some(product) => Ok(HttpResponse::Ok().json(product)),
 
         None => Ok(HttpResponse::NotFound().finish()),
@@ -360,3 +340,39 @@ pub(crate) async fn products_by_product_parent_id_direct(
         Ok(HttpResponse::NotFound().finish())
     }
 }
+
+/// Get Products by it's absents of a product parent
+///
+/// This will only return products without a product parent associated with it
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Products found from database",
+            body = Vec<Product>
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+)]
+#[get("/product/without-product-parent")]
+pub(crate) async fn products_without_product_parent(
+    app: web::Data<App>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let all = {
+        let base = Product::get_all(&app).await?;
+        base.into_iter()
+            .filter(|r| r.parent.is_none())
+            .collect::<Vec<_>>()
+    };
+
+    Ok(HttpResponse::Ok().json(all))
+}
diff --git a/crates/rocie-server/src/api/get/auth/recipe.rs b/crates/rocie-server/src/api/get/auth/recipe.rs
index cb80597..e3032b9 100644
--- a/crates/rocie-server/src/api/get/auth/recipe.rs
+++ b/crates/rocie-server/src/api/get/auth/recipe.rs
@@ -1,11 +1,66 @@
 use actix_identity::Identity;
-use actix_web::{HttpResponse, Responder, error::Result, get, web};
+use actix_web::{HttpRequest, HttpResponse, Responder, error::Result, get, web};
 
 use crate::{
+    api::get::auth::UrlEncodedString,
     app::App,
-    storage::sql::recipe::{Recipe, RecipeId, RecipeIdStub},
+    storage::sql::{
+        recipe::{Recipe, RecipeId, RecipeIdStub},
+        recipe_parent::{RecipeParent, RecipeParentId, RecipeParentIdStub},
+    },
 };
 
+/// Get an recipe by it's name.
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Recipe found in database and fetched",
+            body = Recipe,
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = NOT_FOUND,
+            description = "Recipe not found in database"
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+    params(
+        (
+            "name" = String,
+            description = "Recipe name"
+        ),
+    )
+)]
+#[get("/recipe/by-name/{name}")]
+pub(crate) async fn recipe_by_name(
+    app: web::Data<App>,
+    req: HttpRequest,
+    name: web::Path<String>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    drop(name);
+
+    let name = UrlEncodedString::from_str(
+        req.path()
+            .strip_prefix("/recipe/by-name/")
+            .expect("Will always exists"),
+    );
+    let name = name.percent_decode()?;
+
+    match Recipe::from_name(&app, name).await? {
+        Some(recipe) => Ok(HttpResponse::Ok().json(recipe)),
+        None => Ok(HttpResponse::NotFound().finish()),
+    }
+}
+
 /// Get an recipe by it's id.
 #[utoipa::path(
     responses(
@@ -41,9 +96,7 @@ pub(crate) async fn recipe_by_id(
     id: web::Path<RecipeIdStub>,
     _user: Identity,
 ) -> Result<impl Responder> {
-    let id = id.into_inner();
-
-    match Recipe::from_id(&app, id.into()).await? {
+    match Recipe::from_id(&app, id.into_inner().into()).await? {
         Some(recipe) => Ok(HttpResponse::Ok().json(recipe)),
         None => Ok(HttpResponse::NotFound().finish()),
     }
@@ -55,7 +108,7 @@ pub(crate) async fn recipe_by_id(
         (
             status = OK,
             description = "All recipes found in database and fetched",
-            body = Recipe,
+            body = Vec<Recipe>,
         ),
         (
             status = UNAUTHORIZED,
@@ -74,3 +127,157 @@ pub(crate) async fn recipes(app: web::Data<App>, _user: Identity) -> Result<impl
 
     Ok(HttpResponse::Ok().json(all))
 }
+
+/// Get Recipes by it's recipe parent id
+///
+/// This will also return all recipes below this recipe parent id
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Recipes found from database",
+            body = Vec<Recipe>
+        ),
+        (
+            status = NOT_FOUND,
+            description = "Recipe parent id not found in database"
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+    params(
+        (
+            "id" = RecipeParentId,
+            description = "Recipe parent id"
+        ),
+    )
+)]
+#[get("/recipe/by-recipe-parent-id-indirect/{id}")]
+pub(crate) async fn recipes_by_recipe_parent_id_indirect(
+    app: web::Data<App>,
+    id: web::Path<RecipeParentIdStub>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let id = id.into_inner();
+
+    if let Some(parent) = RecipeParent::from_id(&app, id.into()).await? {
+        async fn collect_recipes(app: &App, parent: RecipeParent) -> Result<Vec<Recipe>> {
+            let mut all = Recipe::get_all(app)
+                .await?
+                .into_iter()
+                .filter(|prod| prod.parent.is_some_and(|val| val == parent.id))
+                .collect::<Vec<_>>();
+
+            if let Some(child) = RecipeParent::get_all(app)
+                .await?
+                .into_iter()
+                .find(|pp| pp.parent.is_some_and(|id| id == parent.id))
+            {
+                all.extend(Box::pin(collect_recipes(app, child)).await?);
+            }
+
+            Ok(all)
+        }
+
+        let all = collect_recipes(&app, parent).await?;
+
+        Ok(HttpResponse::Ok().json(all))
+    } else {
+        Ok(HttpResponse::NotFound().finish())
+    }
+}
+
+/// Get Recipes by it's recipe parent id
+///
+/// This will only return recipes directly associated with this recipe parent id
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Recipes found from database",
+            body = Vec<Recipe>
+        ),
+        (
+            status = NOT_FOUND,
+            description = "Recipe parent id not found in database"
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+    params(
+        (
+            "id" = RecipeParentId,
+            description = "Recipe parent id"
+        ),
+    )
+)]
+#[get("/recipe/by-recipe-parent-id-direct/{id}")]
+pub(crate) async fn recipes_by_recipe_parent_id_direct(
+    app: web::Data<App>,
+    id: web::Path<RecipeParentIdStub>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let id = id.into_inner();
+
+    if let Some(parent) = RecipeParent::from_id(&app, id.into()).await? {
+        let all = Recipe::get_all(&app)
+            .await?
+            .into_iter()
+            .filter(|prod| prod.parent.is_some_and(|val| val == parent.id))
+            .collect::<Vec<_>>();
+
+        Ok(HttpResponse::Ok().json(all))
+    } else {
+        Ok(HttpResponse::NotFound().finish())
+    }
+}
+
+/// Get Recipes by it's absents of a recipe parent
+///
+/// This will only return recipes without a recipe parent associated with it
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Recipes found from database",
+            body = Vec<Recipe>
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+)]
+#[get("/recipe/without-recipe-parent")]
+pub(crate) async fn recipes_without_recipe_parent(
+    app: web::Data<App>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let all = {
+        let base = Recipe::get_all(&app).await?;
+        base.into_iter()
+            .filter(|r| r.parent.is_none())
+            .collect::<Vec<_>>()
+    };
+
+    Ok(HttpResponse::Ok().json(all))
+}
diff --git a/crates/rocie-server/src/api/get/auth/recipe_parent.rs b/crates/rocie-server/src/api/get/auth/recipe_parent.rs
new file mode 100644
index 0000000..d54082b
--- /dev/null
+++ b/crates/rocie-server/src/api/get/auth/recipe_parent.rs
@@ -0,0 +1,108 @@
+use actix_identity::Identity;
+use actix_web::{HttpResponse, Responder, error::Result, get, web};
+
+use crate::{
+    app::App,
+    storage::sql::recipe_parent::{RecipeParent, RecipeParentId, RecipeParentIdStub},
+};
+
+/// Return all registered recipe parents
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "All parents found",
+            body = Vec<RecipeParent>
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+)]
+#[get("/recipe_parents/")]
+pub(crate) async fn recipe_parents(app: web::Data<App>, _user: Identity) -> Result<impl Responder> {
+    let all: Vec<RecipeParent> = RecipeParent::get_all(&app).await?;
+
+    Ok(HttpResponse::Ok().json(all))
+}
+
+/// Return all registered recipe parents, that have no parents themselves
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "All parents found",
+            body = Vec<RecipeParent>
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+)]
+#[get("/recipe_parents_toplevel/")]
+pub(crate) async fn recipe_parents_toplevel(
+    app: web::Data<App>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let all: Vec<RecipeParent> = RecipeParent::get_all(&app)
+        .await?
+        .into_iter()
+        .filter(|parent| parent.parent.is_none())
+        .collect();
+
+    Ok(HttpResponse::Ok().json(all))
+}
+
+/// Return all parents, that have this parent as parent
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "All parents found",
+            body = Vec<RecipeParent>
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    ),
+    params(
+        (
+            "id" = RecipeParentId,
+            description = "Recipe parent id"
+        ),
+    ),
+)]
+#[get("/recipe_parents_under/{id}")]
+pub(crate) async fn recipe_parents_under(
+    app: web::Data<App>,
+    id: web::Path<RecipeParentIdStub>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let id = id.into_inner().into();
+
+    let all: Vec<_> = RecipeParent::get_all(&app)
+        .await?
+        .into_iter()
+        .filter(|parent| parent.parent.is_some_and(|found| found == id))
+        .collect();
+
+    Ok(HttpResponse::Ok().json(all))
+}
diff --git a/crates/rocie-server/src/api/get/no_auth/mod.rs b/crates/rocie-server/src/api/get/no_auth/mod.rs
index 38a041c..5274b4c 100644
--- a/crates/rocie-server/src/api/get/no_auth/mod.rs
+++ b/crates/rocie-server/src/api/get/no_auth/mod.rs
@@ -1,3 +1,8 @@
 use actix_web::web;
 
-pub(crate) fn register_paths(cfg: &mut web::ServiceConfig) {}
+pub(crate) mod state;
+
+pub(crate) fn register_paths(cfg: &mut web::ServiceConfig) {
+    cfg.service(state::is_logged_in)
+        .service(state::can_be_provisioned);
+}
diff --git a/crates/rocie-server/src/api/get/no_auth/state.rs b/crates/rocie-server/src/api/get/no_auth/state.rs
new file mode 100644
index 0000000..31cbfa5
--- /dev/null
+++ b/crates/rocie-server/src/api/get/no_auth/state.rs
@@ -0,0 +1,41 @@
+use actix_identity::Identity;
+use actix_web::{HttpResponse, Responder, Result, get, web};
+
+use crate::{app::App, storage::sql::user::User};
+
+/// Check if you are logged in
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "User login state checked",
+            body = bool
+        )
+    )
+)]
+#[get("/is-logged-in")]
+pub(crate) async fn is_logged_in(user: Option<Identity>) -> impl Responder {
+    HttpResponse::Ok().json(user.is_some())
+}
+
+/// Check if the server can be provisioned
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Provisioning state checked",
+            body = bool
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String
+        )
+    )
+)]
+#[get("/can-be-provisioned")]
+pub(crate) async fn can_be_provisioned(app: web::Data<App>) -> Result<impl Responder> {
+    let users = User::get_all(&app).await?;
+
+    Ok(HttpResponse::Ok().json(users.is_empty()))
+}
diff --git a/crates/rocie-server/src/api/set/auth/mod.rs b/crates/rocie-server/src/api/set/auth/mod.rs
index 4e733a9..6379f22 100644
--- a/crates/rocie-server/src/api/set/auth/mod.rs
+++ b/crates/rocie-server/src/api/set/auth/mod.rs
@@ -4,6 +4,7 @@ pub(crate) mod barcode;
 pub(crate) mod product;
 pub(crate) mod product_parent;
 pub(crate) mod recipe;
+pub(crate) mod recipe_parent;
 pub(crate) mod unit;
 pub(crate) mod unit_property;
 pub(crate) mod user;
@@ -13,6 +14,7 @@ pub(crate) fn register_paths(cfg: &mut web::ServiceConfig) {
         .service(product::associate_barcode)
         .service(product_parent::register_product_parent)
         .service(recipe::add_recipe)
+        .service(recipe_parent::register_recipe_parent)
         .service(unit::register_unit)
         .service(unit_property::register_unit_property)
         .service(barcode::consume_barcode)
diff --git a/crates/rocie-server/src/api/set/auth/recipe.rs b/crates/rocie-server/src/api/set/auth/recipe.rs
index 43a034e..b9f930d 100644
--- a/crates/rocie-server/src/api/set/auth/recipe.rs
+++ b/crates/rocie-server/src/api/set/auth/recipe.rs
@@ -1,5 +1,3 @@
-use std::path::PathBuf;
-
 use actix_identity::Identity;
 use actix_web::{HttpResponse, Responder, error::Result, post, web};
 use serde::Deserialize;
@@ -10,14 +8,18 @@ use crate::{
     storage::sql::{
         insert::Operations,
         recipe::{Recipe, RecipeId},
+        recipe_parent::RecipeParentId,
     },
 };
 
 #[derive(Deserialize, ToSchema)]
 struct RecipeStub {
-    /// The path the recipe should have
-    #[schema(value_type = String)]
-    path: PathBuf,
+    /// The globally unique name of this recipe
+    name: String,
+
+    /// The optional parent of this recipe.
+    #[schema(nullable = false)]
+    parent: Option<RecipeParentId>,
 
     /// The content of this recipe, in cooklang format
     content: String,
@@ -52,7 +54,14 @@ pub(crate) async fn add_recipe(
     let stub = stub.into_inner();
     let mut ops = Operations::new("add recipe parent");
 
-    let recipe = Recipe::new(stub.path, stub.content, &mut ops);
+    let recipe = Recipe::new(
+        &app,
+        stub.name,
+        stub.parent,
+        stub.content,
+        &mut ops,
+    )
+    .await?;
 
     ops.apply(&app).await?;
 
diff --git a/crates/rocie-server/src/api/set/auth/recipe_parent.rs b/crates/rocie-server/src/api/set/auth/recipe_parent.rs
new file mode 100644
index 0000000..e020dd3
--- /dev/null
+++ b/crates/rocie-server/src/api/set/auth/recipe_parent.rs
@@ -0,0 +1,67 @@
+use actix_identity::Identity;
+use actix_web::{HttpResponse, Responder, Result, post, web};
+use serde::Deserialize;
+use utoipa::ToSchema;
+
+use crate::{
+    app::App,
+    storage::sql::{
+        insert::Operations,
+        recipe_parent::{RecipeParent, RecipeParentId},
+    },
+};
+
+#[derive(Deserialize, ToSchema)]
+struct RecipeParentStub {
+    /// The name of the recipe parent
+    name: String,
+
+    /// A description.
+    #[schema(nullable = false)]
+    description: Option<String>,
+
+    /// A parent of this recipe parent, otherwise the parent will be the root of the parent tree.
+    #[schema(nullable = false)]
+    parent: Option<RecipeParentId>,
+}
+
+/// Register a product parent
+#[utoipa::path(
+    responses(
+        (
+            status = OK,
+            description = "Recipe parent successfully registered in database",
+            body = RecipeParentId,
+        ),
+        (
+            status = UNAUTHORIZED,
+            description = "You did not login before calling this endpoint",
+        ),
+        (
+            status = INTERNAL_SERVER_ERROR,
+            description = "Server encountered error",
+            body = String,
+        )
+    ),
+    request_body = RecipeParentStub,
+)]
+#[post("/recipe_parent/new")]
+pub(crate) async fn register_recipe_parent(
+    app: web::Data<App>,
+    parent_stub: web::Json<RecipeParentStub>,
+    _user: Identity,
+) -> Result<impl Responder> {
+    let parent_stub = parent_stub.into_inner();
+    let mut ops = Operations::new("register recipe parent");
+
+    let parent = RecipeParent::register(
+        parent_stub.name,
+        parent_stub.description,
+        parent_stub.parent,
+        &mut ops,
+    );
+
+    ops.apply(&app).await?;
+
+    Ok(HttpResponse::Ok().json(parent.id))
+}
diff --git a/crates/rocie-server/src/api/set/no_auth/user.rs b/crates/rocie-server/src/api/set/no_auth/user.rs
index 7acb482..7ca865c 100644
--- a/crates/rocie-server/src/api/set/no_auth/user.rs
+++ b/crates/rocie-server/src/api/set/no_auth/user.rs
@@ -14,8 +14,8 @@ use crate::{
 
 #[derive(ToSchema, Deserialize, Serialize)]
 struct LoginInfo {
-    /// The id of the user.
-    id: UserId,
+    /// The user name of the user.
+    user_name: String,
 
     /// The password of the user.
     password: String,
@@ -30,7 +30,7 @@ struct LoginInfo {
         ),
         (
             status = NOT_FOUND,
-            description = "User id not found"
+            description = "User name not found"
         ),
         (
             status = FORBIDDEN,
@@ -52,9 +52,9 @@ async fn login(
 ) -> Result<impl Responder> {
     let info = info.into_inner();
 
-    if let Some(user) = User::from_id(&app, info.id).await? {
+    if let Some(user) = User::from_name(&app, info.user_name).await? {
         if user.password_hash.verify(&info.password) {
-            Identity::login(&request.extensions(), info.id.to_string())?;
+            Identity::login(&request.extensions(), user.id.to_string())?;
             Ok(HttpResponse::Ok().finish())
         } else {
             Ok(HttpResponse::Forbidden().finish())
diff --git a/crates/rocie-server/src/main.rs b/crates/rocie-server/src/main.rs
index caa210d..5f3b0ff 100644
--- a/crates/rocie-server/src/main.rs
+++ b/crates/rocie-server/src/main.rs
@@ -1,4 +1,3 @@
-use actix_cors::Cors;
 use actix_web::{
     App, HttpServer,
     cookie::{Key, SameSite},
@@ -27,35 +26,47 @@ async fn main() -> Result<(), std::io::Error> {
     #[derive(OpenApi)]
     #[openapi(
         paths(
+            api::get::auth::inventory::amount_by_id,
             api::get::auth::product::product_by_id,
             api::get::auth::product::product_by_name,
             api::get::auth::product::product_suggestion_by_name,
-            api::get::auth::product::products_registered,
-            api::get::auth::product::products_in_storage,
-            api::get::auth::product::products_by_product_parent_id_indirect,
             api::get::auth::product::products_by_product_parent_id_direct,
+            api::get::auth::product::products_by_product_parent_id_indirect,
+            api::get::auth::product::products_in_storage,
+            api::get::auth::product::products_registered,
+            api::get::auth::product::products_without_product_parent,
             api::get::auth::product_parent::product_parents,
             api::get::auth::product_parent::product_parents_toplevel,
             api::get::auth::product_parent::product_parents_under,
+            api::get::auth::recipe::recipe_by_name,
             api::get::auth::recipe::recipe_by_id,
             api::get::auth::recipe::recipes,
+            api::get::auth::recipe::recipes_by_recipe_parent_id_direct,
+            api::get::auth::recipe::recipes_by_recipe_parent_id_indirect,
+            api::get::auth::recipe::recipes_without_recipe_parent,
+            api::get::auth::recipe_parent::recipe_parents,
+            api::get::auth::recipe_parent::recipe_parents_toplevel,
+            api::get::auth::recipe_parent::recipe_parents_under,
+            api::get::auth::unit::unit_by_id,
             api::get::auth::unit::units,
             api::get::auth::unit::units_by_property_id,
-            api::get::auth::unit::unit_by_id,
-            api::get::auth::unit_property::unit_property_by_id,
             api::get::auth::unit_property::unit_properties,
-            api::get::auth::inventory::amount_by_id,
-            api::get::auth::user::users,
+            api::get::auth::unit_property::unit_property_by_id,
             api::get::auth::user::user_by_id,
+            api::get::auth::user::users,
             //
-            api::set::auth::product::register_product,
+            api::get::no_auth::state::is_logged_in,
+            api::get::no_auth::state::can_be_provisioned,
+            //
+            api::set::auth::barcode::buy_barcode,
+            api::set::auth::barcode::consume_barcode,
             api::set::auth::product::associate_barcode,
+            api::set::auth::product::register_product,
             api::set::auth::product_parent::register_product_parent,
             api::set::auth::recipe::add_recipe,
+            api::set::auth::recipe_parent::register_recipe_parent,
             api::set::auth::unit::register_unit,
             api::set::auth::unit_property::register_unit_property,
-            api::set::auth::barcode::buy_barcode,
-            api::set::auth::barcode::consume_barcode,
             api::set::auth::user::register_user,
             //
             api::set::no_auth::user::login,
@@ -90,8 +101,6 @@ async fn main() -> Result<(), std::io::Error> {
 
             let srv = HttpServer::new(move || {
                 App::new()
-                    // TODO: Remove before an actual deploy <2025-09-26>
-                    .wrap(Cors::permissive())
                     .wrap(Logger::new(
                         r#"%a "%r" -> %s %b ("%{Referer}i" "%{User-Agent}i" %T s)"#,
                     ))
diff --git a/crates/rocie-server/src/storage/migrate/sql/0->1.sql b/crates/rocie-server/src/storage/migrate/sql/0->1.sql
index e3dd879..ba44c68 100644
--- a/crates/rocie-server/src/storage/migrate/sql/0->1.sql
+++ b/crates/rocie-server/src/storage/migrate/sql/0->1.sql
@@ -14,17 +14,29 @@ CREATE TABLE version (
     valid_to    INTEGER UNIQUE          CHECK (valid_to > valid_from)
 ) STRICT;
 
--- Encodes the tree structure of the products.
--- A parent cannot be a product, but can have parents on it's own.
+-- Encodes the tree structure of the product parents.
+-- A product parent cannot be a product, but can have parents on it's own.
 -- TODO: Fix the possibility for cyclic parent-ship entries <2025-09-05>
-CREATE TABLE parents (
+CREATE TABLE product_parents (
     id                          TEXT UNIQUE NOT NULL PRIMARY KEY,
     parent                      TEXT                             DEFAULT NULL CHECK (
                                                                             id IS NOT parent
                                                                         ),
     name                        TEXT UNIQUE NOT NULL,
     description                 TEXT,
-    FOREIGN KEY(parent) REFERENCES parents(id)
+    FOREIGN KEY(parent) REFERENCES product_parents(id)
+) STRICT;
+
+-- Encodes the tree structure of the recipe parents.
+-- TODO: Fix the possibility for cyclic parent-ship entries <2025-09-05>
+CREATE TABLE recipe_parents (
+    id                          TEXT UNIQUE NOT NULL PRIMARY KEY,
+    parent                      TEXT                             DEFAULT NULL CHECK (
+                                                                            id IS NOT parent
+                                                                        ),
+    name                        TEXT UNIQUE NOT NULL,
+    description                 TEXT,
+    FOREIGN KEY(parent) REFERENCES recipe_parents(id)
 ) STRICT;
 
 -- Stores the registered users.
@@ -71,7 +83,7 @@ CREATE TABLE products (
     description                 TEXT,
     parent                      TEXT                             DEFAULT NULL,
     unit_property               TEXT        NOT NULL,
-    FOREIGN KEY(parent) REFERENCES parents(id),
+    FOREIGN KEY(parent) REFERENCES product_parents(id),
     FOREIGN KEY(unit_property) REFERENCES unit_properties(id)
 ) STRICT;
 
@@ -123,8 +135,10 @@ CREATE TABLE unit_properties (
 
 CREATE TABLE recipies (
     id                          TEXT UNIQUE NOT NULL PRIMARY KEY,
-    path                        TEXT UNIQUE NOT NULL,
-    content                     TEXT        NOT NULL
+    name                        TEXT UNIQUE NOT NULL,
+    parent                      TEXT,
+    content                     TEXT        NOT NULL,
+    FOREIGN KEY(parent) REFERENCES recipe_parents(id)
 ) STRICT;
 
 -- Encodes unit conversions:
diff --git a/crates/rocie-server/src/storage/sql/get/mod.rs b/crates/rocie-server/src/storage/sql/get/mod.rs
index 92b34aa..a6ee0e1 100644
--- a/crates/rocie-server/src/storage/sql/get/mod.rs
+++ b/crates/rocie-server/src/storage/sql/get/mod.rs
@@ -2,6 +2,7 @@ pub(crate) mod barcode;
 pub(crate) mod product;
 pub(crate) mod product_amount;
 pub(crate) mod product_parent;
+pub(crate) mod recipe_parent;
 pub(crate) mod recipe;
 pub(crate) mod unit;
 pub(crate) mod unit_property;
diff --git a/crates/rocie-server/src/storage/sql/get/product/mod.rs b/crates/rocie-server/src/storage/sql/get/product/mod.rs
index 915da81..3d8b6e6 100644
--- a/crates/rocie-server/src/storage/sql/get/product/mod.rs
+++ b/crates/rocie-server/src/storage/sql/get/product/mod.rs
@@ -66,7 +66,7 @@ impl Product {
         }
     }
 
-    pub(crate) async fn from_name(app: &App, name: String) -> Result<Option<Self>, from_id::Error> {
+    pub(crate) async fn from_name(app: &App, name: &str) -> Result<Option<Self>, from_id::Error> {
         let record = query!(
             "
         SELECT name, id, unit_property, description, parent
diff --git a/crates/rocie-server/src/storage/sql/get/product_parent/mod.rs b/crates/rocie-server/src/storage/sql/get/product_parent/mod.rs
index 5b85b62..243ae1e 100644
--- a/crates/rocie-server/src/storage/sql/get/product_parent/mod.rs
+++ b/crates/rocie-server/src/storage/sql/get/product_parent/mod.rs
@@ -10,7 +10,7 @@ impl ProductParent {
         let records = query!(
             "
         SELECT id, parent, name, description
-        FROM parents
+        FROM product_parents
 "
         )
         .fetch_all(&app.db)
@@ -40,7 +40,7 @@ impl ProductParent {
         let record = query!(
             "
         SELECT parent, name, description
-        FROM parents
+        FROM product_parents
         WHERE id = ?
 ",
             id
diff --git a/crates/rocie-server/src/storage/sql/get/recipe/mod.rs b/crates/rocie-server/src/storage/sql/get/recipe/mod.rs
index 9d6dc79..f433541 100644
--- a/crates/rocie-server/src/storage/sql/get/recipe/mod.rs
+++ b/crates/rocie-server/src/storage/sql/get/recipe/mod.rs
@@ -1,15 +1,38 @@
 use crate::{
     app::App,
-    storage::sql::recipe::{Recipe, RecipeId},
+    storage::sql::{
+        recipe::{CooklangRecipe, Recipe, RecipeId},
+        recipe_parent::RecipeParentId,
+    },
 };
 
 use sqlx::query;
 
+pub(crate) mod parse {
+    use crate::storage::sql::recipe::conversion;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to convert from cooklang recipe to our own struct")]
+        Conversion(#[from] conversion::Error),
+    }
+}
+
+async fn recipe_from_content(app: &App, content: &str) -> Result<CooklangRecipe, parse::Error> {
+    // NOTE: We can ignore warnings here, as we should already have handled them at the recipe
+    // insert point. <2026-01-31>
+    let (output, _warnings) = cooklang::parse(content)
+        .into_result()
+        .expect("The values in the db should always be valid, as we checked before inserting them");
+
+    Ok(CooklangRecipe::from(app, output).await?)
+}
+
 impl Recipe {
     pub(crate) async fn from_id(app: &App, id: RecipeId) -> Result<Option<Self>, from_id::Error> {
         let record = query!(
             "
-        SELECT content, path
+        SELECT name, parent, content
         FROM recipies
         WHERE id = ?
 ",
@@ -21,11 +44,33 @@ impl Recipe {
         if let Some(record) = record {
             Ok(Some(Self {
                 id,
-                path: record
-                    .path
-                    .parse()
-                    .expect("Was a path before, should still be one"),
-                content: record.content,
+                content: recipe_from_content(app, &record.content).await?,
+                name: record.name,
+                parent: record.parent.map(|id| RecipeParentId::from_db(&id)),
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub(crate) async fn from_name(app: &App, name: String) -> Result<Option<Self>, from_id::Error> {
+        let record = query!(
+            "
+        SELECT id, parent, content
+        FROM recipies
+        WHERE name = ?
+",
+            name
+        )
+        .fetch_optional(&app.db)
+        .await?;
+
+        if let Some(record) = record {
+            Ok(Some(Self {
+                id: RecipeId::from_db(&record.id),
+                content: recipe_from_content(app, &record.content).await?,
+                name,
+                parent: record.parent.map(|id| RecipeParentId::from_db(&id)),
             }))
         } else {
             Ok(None)
@@ -35,31 +80,39 @@ impl Recipe {
     pub(crate) async fn get_all(app: &App) -> Result<Vec<Self>, get_all::Error> {
         let records = query!(
             "
-        SELECT id, content, path
+        SELECT id, name, parent, content
         FROM recipies
 ",
         )
         .fetch_all(&app.db)
         .await?;
 
-        Ok(records
-            .into_iter()
-            .map(|record| Self {
+        let mut output = vec![];
+        for record in records {
+            output.push(Self {
                 id: RecipeId::from_db(&record.id),
-                path: record.path.parse().expect("Is still valid"),
-                content: record.content,
-            })
-            .collect())
+                content: recipe_from_content(app, &record.content).await?,
+                name: record.name,
+                parent: record.parent.map(|id| RecipeParentId::from_db(&id)),
+            });
+        }
+
+        Ok(output)
     }
 }
 
 pub(crate) mod from_id {
     use actix_web::ResponseError;
 
+    use crate::storage::sql::get::recipe::parse;
+
     #[derive(thiserror::Error, Debug)]
     pub(crate) enum Error {
-        #[error("Failed to execute the sql query")]
+        #[error("Failed to execute the sql query: `{0}`")]
         SqlError(#[from] sqlx::Error),
+
+        #[error("Failed to parse the recipe content as cooklang recipe: `{0}`")]
+        RecipeParse(#[from] parse::Error),
     }
 
     impl ResponseError for Error {}
@@ -68,10 +121,15 @@ pub(crate) mod from_id {
 pub(crate) mod get_all {
     use actix_web::ResponseError;
 
+    use crate::storage::sql::get::recipe::parse;
+
     #[derive(thiserror::Error, Debug)]
     pub(crate) enum Error {
         #[error("Failed to execute the sql query")]
         SqlError(#[from] sqlx::Error),
+
+        #[error("Failed to parse the recipe content as cooklang recipe")]
+        RecipeParse(#[from] parse::Error),
     }
 
     impl ResponseError for Error {}
diff --git a/crates/rocie-server/src/storage/sql/get/recipe_parent/mod.rs b/crates/rocie-server/src/storage/sql/get/recipe_parent/mod.rs
new file mode 100644
index 0000000..d53e853
--- /dev/null
+++ b/crates/rocie-server/src/storage/sql/get/recipe_parent/mod.rs
@@ -0,0 +1,85 @@
+use crate::{
+    app::App,
+    storage::sql::{
+        recipe_parent::{RecipeParent, RecipeParentId},
+    },
+};
+
+use sqlx::query;
+
+impl RecipeParent {
+    pub(crate) async fn get_all(app: &App) -> Result<Vec<Self>, get_all::Error> {
+        let records = query!(
+            "
+        SELECT id, parent, name, description
+        FROM recipe_parents
+"
+        )
+        .fetch_all(&app.db)
+        .await?;
+
+        let mut all = Vec::with_capacity(records.len());
+        for record in records {
+            let parent = Self {
+                id: RecipeParentId::from_db(&record.id),
+                parent: record.parent.map(|parent| RecipeParentId::from_db(&parent)),
+                name: record.name,
+                description: record.description,
+            };
+
+            all.push(parent);
+        }
+
+        Ok(all)
+    }
+
+    pub(crate) async fn from_id(
+        app: &App,
+        id: RecipeParentId,
+    ) -> Result<Option<Self>, from_id::Error> {
+        let record = query!(
+            "
+        SELECT parent, name, description
+        FROM recipe_parents
+        WHERE id = ?
+",
+            id
+        )
+        .fetch_optional(&app.db)
+        .await?;
+
+        match record {
+            Some(record) => Ok(Some(Self {
+                id,
+                parent: record.parent.map(|parent| RecipeParentId::from_db(&parent)),
+                name: record.name,
+                description: record.description,
+            })),
+            None => Ok(None),
+        }
+    }
+}
+
+pub(crate) mod from_id {
+    use actix_web::ResponseError;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to execute the sql query")]
+        SqlError(#[from] sqlx::Error),
+    }
+
+    impl ResponseError for Error {}
+}
+
+pub(crate) mod get_all {
+    use actix_web::ResponseError;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to execute the sql query")]
+        SqlError(#[from] sqlx::Error),
+    }
+
+    impl ResponseError for Error {}
+}
diff --git a/crates/rocie-server/src/storage/sql/get/user/mod.rs b/crates/rocie-server/src/storage/sql/get/user/mod.rs
index e36c6cf..e09ef67 100644
--- a/crates/rocie-server/src/storage/sql/get/user/mod.rs
+++ b/crates/rocie-server/src/storage/sql/get/user/mod.rs
@@ -50,6 +50,33 @@ impl User {
             Ok(None)
         }
     }
+
+    pub(crate) async fn from_name(
+        app: &App,
+        name: String,
+    ) -> Result<Option<Self>, from_name::Error> {
+        let record = query!(
+            "
+        SELECT id, name, password_hash, description
+        FROM users
+        WHERE name = ?
+",
+            name
+        )
+        .fetch_optional(&app.db)
+        .await?;
+
+        if let Some(record) = record {
+            Ok(Some(Self {
+                name: record.name,
+                description: record.description,
+                id: UserId::from_db(&record.id),
+                password_hash: PasswordHash::from_db(record.password_hash),
+            }))
+        } else {
+            Ok(None)
+        }
+    }
 }
 
 pub(crate) mod get_all {
@@ -75,3 +102,15 @@ pub(crate) mod from_id {
 
     impl ResponseError for Error {}
 }
+
+pub(crate) mod from_name {
+    use actix_web::ResponseError;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to execute the sql query")]
+        SqlError(#[from] sqlx::Error),
+    }
+
+    impl ResponseError for Error {}
+}
diff --git a/crates/rocie-server/src/storage/sql/insert/mod.rs b/crates/rocie-server/src/storage/sql/insert/mod.rs
index 673cbdd..b92a88c 100644
--- a/crates/rocie-server/src/storage/sql/insert/mod.rs
+++ b/crates/rocie-server/src/storage/sql/insert/mod.rs
@@ -11,6 +11,7 @@ pub(crate) mod barcode;
 pub(crate) mod product;
 pub(crate) mod product_parent;
 pub(crate) mod recipe;
+pub(crate) mod recipe_parent;
 pub(crate) mod unit;
 pub(crate) mod unit_property;
 pub(crate) mod user;
diff --git a/crates/rocie-server/src/storage/sql/insert/product_parent/mod.rs b/crates/rocie-server/src/storage/sql/insert/product_parent/mod.rs
index 644778f..72fb564 100644
--- a/crates/rocie-server/src/storage/sql/insert/product_parent/mod.rs
+++ b/crates/rocie-server/src/storage/sql/insert/product_parent/mod.rs
@@ -31,7 +31,7 @@ impl Transactionable for Operation {
             } => {
                 query!(
                     "
-                    INSERT INTO parents (id, name, description, parent)
+                    INSERT INTO product_parents (id, name, description, parent)
                     VALUES (?,?,?,?)
 ",
                     id,
@@ -56,7 +56,7 @@ impl Transactionable for Operation {
             } => {
                 query!(
                     "
-                    DELETE FROM products
+                    DELETE FROM product_parents
                     WHERE id = ? AND name = ? AND description = ? AND parent = ?;
 ",
                     id,
diff --git a/crates/rocie-server/src/storage/sql/insert/recipe/mod.rs b/crates/rocie-server/src/storage/sql/insert/recipe/mod.rs
index b223bfe..b60874f 100644
--- a/crates/rocie-server/src/storage/sql/insert/recipe/mod.rs
+++ b/crates/rocie-server/src/storage/sql/insert/recipe/mod.rs
@@ -1,19 +1,23 @@
-use std::path::PathBuf;
-
+use cooklang::{Converter, CooklangParser, Extensions};
 use serde::{Deserialize, Serialize};
 use sqlx::query;
 use uuid::Uuid;
 
-use crate::storage::sql::{
-    insert::{Operations, Transactionable},
-    recipe::{Recipe, RecipeId},
+use crate::{
+    app::App,
+    storage::sql::{
+        insert::{Operations, Transactionable},
+        recipe::{CooklangRecipe, Recipe, RecipeId},
+        recipe_parent::RecipeParentId,
+    },
 };
 
 #[derive(Debug, Deserialize, Serialize)]
 pub(crate) enum Operation {
     New {
         id: RecipeId,
-        path: PathBuf,
+        name: String,
+        parent: Option<RecipeParentId>,
         content: String,
     },
 }
@@ -24,16 +28,20 @@ impl Transactionable for Operation {
 
     async fn apply(self, txn: &mut sqlx::SqliteConnection) -> Result<(), apply::Error> {
         match self {
-            Operation::New { id, path, content } => {
-                let path = path.display().to_string();
-
+            Operation::New {
+                id,
+                name,
+                parent,
+                content,
+            } => {
                 query!(
                     "
-                    INSERT INTO recipies (id, path, content)
-                    VALUES (?, ?, ?)
+                    INSERT INTO recipies (id, name, parent, content)
+                    VALUES (?, ?, ?, ?)
 ",
                     id,
-                    path,
+                    name,
+                    parent,
                     content,
                 )
                 .execute(txn)
@@ -45,16 +53,20 @@ impl Transactionable for Operation {
 
     async fn undo(self, txn: &mut sqlx::SqliteConnection) -> Result<(), undo::Error> {
         match self {
-            Operation::New { id, path, content } => {
-                let path = path.display().to_string();
-
+            Operation::New {
+                id,
+                name,
+                parent,
+                content,
+            } => {
                 query!(
                     "
                     DELETE FROM recipies
-                    WHERE id = ? AND path = ? AND content = ?
+                    WHERE id = ? AND name = ? AND parent = ? AND content = ?
 ",
                     id,
-                    path,
+                    name,
+                    parent,
                     content
                 )
                 .execute(txn)
@@ -79,17 +91,50 @@ pub(crate) mod apply {
         SqlError(#[from] sqlx::Error),
     }
 }
+pub(crate) mod new {
+    use actix_web::ResponseError;
+
+    use crate::storage::sql::recipe::conversion;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to parse the recipe contents as cooklang: `{0}`")]
+        RecipeParse(#[from] cooklang::error::SourceReport),
+
+        #[error("Failed to convert the cooklang recipe to our struct: `{0}`")]
+        RecipeConvert(#[from] conversion::Error),
+    }
+
+    impl ResponseError for Error {}
+}
 
 impl Recipe {
-    pub(crate) fn new(path: PathBuf, content: String, ops: &mut Operations<Operation>) -> Self {
+    pub(crate) async fn new(
+        app: &App,
+        name: String,
+        parent: Option<RecipeParentId>,
+        content: String,
+        ops: &mut Operations<Operation>,
+    ) -> Result<Self, new::Error> {
         let id = RecipeId::from(Uuid::new_v4());
 
+        let parser = CooklangParser::new(Extensions::empty(), Converter::bundled());
+
+        // TODO: Somehow return the warnings <2026-01-31>
+        let (recipe, _warnings) = parser.parse(&content).into_result()?;
+
         ops.push(Operation::New {
             id,
-            path: path.clone(),
-            content: content.clone(),
+            content,
+            name: name.clone(),
+            parent,
         });
 
-        Self { id, path, content }
+        Ok(Self {
+            id,
+            name,
+            parent,
+            content: CooklangRecipe::from(app, recipe).await?,
+        })
     }
 }
diff --git a/crates/rocie-server/src/storage/sql/insert/recipe_parent/mod.rs b/crates/rocie-server/src/storage/sql/insert/recipe_parent/mod.rs
new file mode 100644
index 0000000..95bc6f1
--- /dev/null
+++ b/crates/rocie-server/src/storage/sql/insert/recipe_parent/mod.rs
@@ -0,0 +1,113 @@
+use serde::{Deserialize, Serialize};
+use sqlx::query;
+use uuid::Uuid;
+
+use crate::storage::sql::{
+    insert::{Operations, Transactionable},
+    recipe_parent::{RecipeParent, RecipeParentId},
+};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub(crate) enum Operation {
+    RegisterRecipeParent {
+        id: RecipeParentId,
+        name: String,
+        description: Option<String>,
+        parent: Option<RecipeParentId>,
+    },
+}
+
+impl Transactionable for Operation {
+    type ApplyError = apply::Error;
+    type UndoError = undo::Error;
+
+    async fn apply(self, txn: &mut sqlx::SqliteConnection) -> Result<(), apply::Error> {
+        match self {
+            Operation::RegisterRecipeParent {
+                id,
+                name,
+                description,
+                parent,
+            } => {
+                query!(
+                    "
+                    INSERT INTO recipe_parents (id, name, description, parent)
+                    VALUES (?,?,?,?)
+",
+                    id,
+                    name,
+                    description,
+                    parent
+                )
+                .execute(txn)
+                .await?;
+            }
+        }
+        Ok(())
+    }
+
+    async fn undo(self, txn: &mut sqlx::SqliteConnection) -> Result<(), undo::Error> {
+        match self {
+            Operation::RegisterRecipeParent {
+                id,
+                name,
+                description,
+                parent,
+            } => {
+                query!(
+                    "
+                    DELETE FROM recipe_parents
+                    WHERE id = ? AND name = ? AND description = ? AND parent = ?;
+",
+                    id,
+                    name,
+                    description,
+                    parent,
+                )
+                .execute(txn)
+                .await?;
+            }
+        }
+        Ok(())
+    }
+}
+
+pub(crate) mod undo {
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to execute undo sql statments: {0}")]
+        SqlError(#[from] sqlx::Error),
+    }
+}
+pub(crate) mod apply {
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to execute apply sql statments: {0}")]
+        SqlError(#[from] sqlx::Error),
+    }
+}
+
+impl RecipeParent {
+    pub(crate) fn register(
+        name: String,
+        description: Option<String>,
+        parent: Option<RecipeParentId>,
+        ops: &mut Operations<Operation>,
+    ) -> Self {
+        let id = RecipeParentId::from(Uuid::new_v4());
+
+        ops.push(Operation::RegisterRecipeParent {
+            id,
+            name: name.clone(),
+            description: description.clone(),
+            parent,
+        });
+
+        Self {
+            id,
+            name,
+            description,
+            parent,
+        }
+    }
+}
diff --git a/crates/rocie-server/src/storage/sql/mod.rs b/crates/rocie-server/src/storage/sql/mod.rs
index 315c251..c37e68f 100644
--- a/crates/rocie-server/src/storage/sql/mod.rs
+++ b/crates/rocie-server/src/storage/sql/mod.rs
@@ -7,6 +7,7 @@ pub(crate) mod product;
 pub(crate) mod product_amount;
 pub(crate) mod product_parent;
 pub(crate) mod recipe;
+pub(crate) mod recipe_parent;
 pub(crate) mod unit;
 pub(crate) mod unit_property;
 pub(crate) mod user;
diff --git a/crates/rocie-server/src/storage/sql/product.rs b/crates/rocie-server/src/storage/sql/product.rs
index 00c79d3..c2c32ec 100644
--- a/crates/rocie-server/src/storage/sql/product.rs
+++ b/crates/rocie-server/src/storage/sql/product.rs
@@ -17,6 +17,7 @@ pub(crate) struct Product {
     /// The parent this product has.
     ///
     /// This is effectively it's anchor in the product DAG.
+    /// None means, that it has no parents and as such is in the toplevel.
     #[schema(nullable = false)]
     pub(crate) parent: Option<ProductParentId>,
 
diff --git a/crates/rocie-server/src/storage/sql/product_amount.rs b/crates/rocie-server/src/storage/sql/product_amount.rs
index 0f19afc..dafe43a 100644
--- a/crates/rocie-server/src/storage/sql/product_amount.rs
+++ b/crates/rocie-server/src/storage/sql/product_amount.rs
@@ -3,7 +3,7 @@ use utoipa::ToSchema;
 
 use crate::storage::sql::{product::ProductId, unit::UnitAmount};
 
-#[derive(Clone, ToSchema, Serialize, Deserialize)]
+#[derive(Debug, Clone, ToSchema, Serialize, Deserialize, PartialEq)]
 pub(crate) struct ProductAmount {
     pub(crate) product_id: ProductId,
     pub(crate) amount: UnitAmount,
diff --git a/crates/rocie-server/src/storage/sql/recipe.rs b/crates/rocie-server/src/storage/sql/recipe.rs
index 835d98b..1fc3b56 100644
--- a/crates/rocie-server/src/storage/sql/recipe.rs
+++ b/crates/rocie-server/src/storage/sql/recipe.rs
@@ -1,18 +1,391 @@
-use std::path::PathBuf;
+#![expect(clippy::unused_async)]
 
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-use crate::storage::sql::mk_id;
+use crate::{
+    app::App,
+    storage::sql::{
+        mk_id,
+        product::{Product, ProductId},
+        product_amount::ProductAmount,
+        recipe_parent::RecipeParentId,
+        unit::UnitAmount,
+    },
+};
 
+macro_rules! for_in {
+    ($value:expr, |$name:ident| $closoure:expr) => {{
+        let fun = async |$name| $closoure;
+
+        let mut output = Vec::with_capacity($value.len());
+        for $name in $value {
+            output.push(fun($name).await?);
+        }
+        output
+    }};
+}
+
+/// An recipe.
+///
+/// These are transparently expressed in cooklang.
 #[derive(ToSchema, Debug, Clone, Serialize, Deserialize)]
 pub(crate) struct Recipe {
+    /// The unique id of this recipe.
     pub(crate) id: RecipeId,
 
-    #[schema(value_type = String)]
-    pub(crate) path: PathBuf,
+    /// The name of the recipe.
+    ///
+    /// This should be globally unique, to make searching easier for the user.
+    pub(crate) name: String,
+
+    /// The parent this recipe has.
+    ///
+    /// This is effectively it's anchor in the recipe DAG.
+    /// None means, that it has no parents and as such is in the toplevel.
+    #[schema(nullable = false)]
+    pub(crate) parent: Option<RecipeParentId>,
 
-    pub(crate) content: String,
+    /// The actual content of this recipe.
+    pub(crate) content: CooklangRecipe,
 }
 
 mk_id!(RecipeId and RecipeIdStub);
+
+/// A complete recipe
+///
+/// The recipes do not have a name. You give it externally or maybe use
+/// some metadata key.
+///
+/// The recipe returned from parsing is a [`ScalableRecipe`].
+///
+/// The difference between [`ScalableRecipe`] and [`ScaledRecipe`] is in the
+/// values of the quantities of ingredients, cookware and timers. The parser
+/// returns [`ScalableValue`]s and after scaling, these are converted to regular
+/// [`Value`]s.
+#[derive(ToSchema, Debug, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct CooklangRecipe {
+    /// Metadata as read from preamble
+    pub(crate) metadata: Metadata,
+
+    /// Each of the sections
+    ///
+    /// If no sections declared, a section without name
+    /// is the default.
+    pub(crate) sections: Vec<Section>,
+
+    /// All the ingredients
+    pub(crate) ingredients: Vec<Ingredient>,
+
+    /// All the cookware
+    pub(crate) cookware: Vec<Cookware>,
+
+    /// All the timers
+    pub(crate) timers: Vec<Timer>,
+}
+
+/// A section holding steps
+#[derive(Debug, ToSchema, Default, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct Section {
+    /// Name of the section
+    #[schema(nullable = false)]
+    pub(crate) name: Option<String>,
+
+    /// Content inside
+    pub(crate) content: Vec<Content>,
+}
+
+/// Each type of content inside a section
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type", content = "value", rename_all = "camelCase")]
+pub(crate) enum Content {
+    /// A step
+    Step(Step),
+
+    /// A paragraph of just text, no instructions
+    Text(String),
+}
+
+/// A step holding step [`Item`]s
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct Step {
+    /// [`Item`]s inside
+    pub(crate) items: Vec<Item>,
+
+    /// Step number
+    ///
+    /// The step numbers start at 1 in each section and increase with non
+    /// text step.
+    pub(crate) number: u32,
+}
+
+/// A step item
+///
+/// Except for [`Item::Text`], the value is the index where the item is located
+/// in it's corresponding [`Vec`] in the [`Recipe`].
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub(crate) enum Item {
+    /// Just plain text
+    Text {
+        value: String,
+    },
+    Ingredient {
+        index: usize,
+    },
+    Cookware {
+        index: usize,
+    },
+    Timer {
+        index: usize,
+    },
+    InlineQuantity {
+        index: usize,
+    },
+}
+
+/// A recipe ingredient
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) enum Ingredient {
+    /// This ingredient is a registered product.
+    RegisteredProduct {
+        id: ProductId,
+
+        /// Alias
+        #[schema(nullable = false)]
+        alias: Option<String>,
+
+        /// Quantity
+        #[schema(nullable = false)]
+        quantity: Option<ProductAmount>,
+    },
+
+    /// This ingredient is a not yet registered product.
+    NotRegisteredProduct {
+        name: String,
+
+        /// Quantity
+        #[schema(nullable = false)]
+        quantity: Option<UnitAmount>,
+    },
+
+    /// This ingredient is a reference to another recipe.
+    RecipeReference { id: RecipeId },
+}
+
+/// A recipe cookware item
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct Cookware {
+    /// Name
+    pub(crate) name: String,
+
+    /// Alias
+    #[schema(nullable = false)]
+    pub(crate) alias: Option<String>,
+
+    /// Amount needed
+    ///
+    /// Note that this is a value, not a quantity, so it doesn't have units.
+    #[schema(nullable = false)]
+    pub(crate) quantity: Option<usize>,
+
+    /// Note
+    #[schema(nullable = false)]
+    pub(crate) note: Option<String>,
+}
+
+/// A recipe timer
+///
+/// If created from parsing, at least one of the fields is guaranteed to be
+/// [`Some`].
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct Timer {
+    /// Name
+    #[schema(nullable = false)]
+    pub(crate) name: Option<String>,
+
+    /// Time quantity
+    pub(crate) quantity: UnitAmount,
+}
+
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct Metadata {
+    #[schema(nullable = false)]
+    title: Option<String>,
+
+    #[schema(nullable = false)]
+    description: Option<String>,
+
+    #[schema(nullable = false)]
+    tags: Option<Vec<String>>,
+
+    #[schema(nullable = false)]
+    author: Option<NameAndUrl>,
+
+    #[schema(nullable = false)]
+    source: Option<NameAndUrl>,
+    // time: Option<serde_yaml::Value>,
+    // prep_time: Option<serde_yaml::Value>,
+    // cook_time: Option<serde_yaml::Value>,
+    // servings: Option<serde_yaml::Value>,
+    // difficulty: Option<serde_yaml::Value>,
+    // cuisine: Option<serde_yaml::Value>,
+    // diet: Option<serde_yaml::Value>,
+    // images: Option<serde_yaml::Value>,
+    // locale: Option<serde_yaml::Value>,
+
+    // other: serde_yaml::Mapping,
+}
+
+pub(crate) mod conversion {
+    use crate::storage::sql::get::product::from_id;
+
+    #[derive(thiserror::Error, Debug)]
+    pub(crate) enum Error {
+        #[error("Failed to get a product by id: `{0}`")]
+        ProductAccess(#[from] from_id::Error),
+    }
+}
+
+#[derive(Debug, ToSchema, Serialize, Deserialize, PartialEq, Clone)]
+pub(crate) struct NameAndUrl {
+    #[schema(nullable = false)]
+    name: Option<String>,
+
+    #[schema(nullable = false)]
+    url: Option<String>,
+}
+impl NameAndUrl {
+    async fn from(value: cooklang::metadata::NameAndUrl) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            name: value.name().map(|v| v.to_owned()),
+            url: value.url().map(|v| v.to_owned()),
+        })
+    }
+}
+
+impl CooklangRecipe {
+    pub(crate) async fn from(
+        app: &App,
+        value: cooklang::Recipe,
+    ) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            metadata: Metadata::from(value.metadata).await?,
+            sections: for_in!(value.sections, |s| Section::from(s).await),
+            ingredients: for_in!(value.ingredients, |i| Ingredient::from(app, i).await),
+            cookware: for_in!(value.cookware, |c| Cookware::from(c).await),
+            timers: for_in!(value.timers, |t| Timer::from(t).await),
+        })
+    }
+}
+
+impl Metadata {
+    async fn from(value: cooklang::Metadata) -> Result<Self, conversion::Error> {
+        let author = if let Some(author) = value.author() {
+            Some(NameAndUrl::from(author).await?)
+        } else {
+            None
+        };
+        let source = if let Some(source) = value.source() {
+            Some(NameAndUrl::from(source).await?)
+        } else {
+            None
+        };
+
+        Ok(Self {
+            title: value.title().map(str::to_owned),
+            description: value.description().map(str::to_owned),
+            tags: value
+                .tags()
+                .map(|vec| vec.into_iter().map(|c| c.to_string()).collect()),
+            author,
+            source,
+            // time: value.time(&Converter::bundled()).map(|t| t.total()),
+            // prep_time: todo!(),
+            // cook_time: todo!(),
+            // servings: todo!(),
+            // difficulty: todo!(),
+            // cuisine: todo!(),
+            // diet: todo!(),
+            // images: todo!(),
+            // locale: todo!(),
+            // other: value.map_filtered().,
+        })
+    }
+}
+
+impl Section {
+    async fn from(value: cooklang::Section) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            name: value.name,
+            content: for_in!(value.content, |c| Content::from(c).await),
+        })
+    }
+}
+impl Content {
+    async fn from(value: cooklang::Content) -> Result<Self, conversion::Error> {
+        match value {
+            cooklang::Content::Step(step) => Ok(Self::Step(Step::from(step).await?)),
+            cooklang::Content::Text(text) => Ok(Self::Text(text)),
+        }
+    }
+}
+impl Step {
+    async fn from(value: cooklang::Step) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            items: for_in!(value.items, |item| Item::from(item).await),
+            number: value.number,
+        })
+    }
+}
+impl Item {
+    async fn from(value: cooklang::Item) -> Result<Self, conversion::Error> {
+        match value {
+            cooklang::Item::Text { value } => Ok(Self::Text { value }),
+            cooklang::Item::Ingredient { index } => Ok(Self::Ingredient { index }),
+            cooklang::Item::Cookware { index } => Ok(Self::Cookware { index }),
+            cooklang::Item::Timer { index } => Ok(Self::Timer { index }),
+            cooklang::Item::InlineQuantity { index } => Ok(Self::InlineQuantity { index }),
+        }
+    }
+}
+impl Ingredient {
+    async fn from(app: &App, value: cooklang::Ingredient) -> Result<Self, conversion::Error> {
+        if value.name.starts_with('/') {
+            Ok(Self::RecipeReference { id: todo!() })
+        } else if let Some(product) = Product::from_name(&app, value.name.as_str()).await? {
+            Ok(Self::RegisteredProduct {
+                id: product.id,
+                alias: value.alias,
+                quantity: None,
+            })
+        } else {
+            Ok(Self::NotRegisteredProduct {
+                name: value.name,
+                quantity: None,
+            })
+        }
+    }
+}
+impl Cookware {
+    async fn from(value: cooklang::Cookware) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            name: value.name,
+            alias: value.alias,
+            quantity: value.quantity.map(|q| match q.value() {
+                cooklang::Value::Number(number) => number.value() as usize,
+                cooklang::Value::Range { start, end } => todo!(),
+                cooklang::Value::Text(_) => todo!(),
+            }),
+            note: value.note,
+        })
+    }
+}
+impl Timer {
+    async fn from(value: cooklang::Timer) -> Result<Self, conversion::Error> {
+        Ok(Self {
+            name: value.name,
+            quantity: todo!(),
+        })
+    }
+}
diff --git a/crates/rocie-server/src/storage/sql/recipe_parent.rs b/crates/rocie-server/src/storage/sql/recipe_parent.rs
new file mode 100644
index 0000000..6225a4b
--- /dev/null
+++ b/crates/rocie-server/src/storage/sql/recipe_parent.rs
@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use crate::storage::sql::mk_id;
+
+/// The grouping system for recipes.
+///
+/// Every recipe can have a related parent, and every parent can have a parent themselves.
+/// As such, the recipe list constructs a DAG.
+#[derive(Clone, ToSchema, Serialize, Deserialize)]
+pub(crate) struct RecipeParent {
+    /// The id of the recipe parent.
+    pub(crate) id: RecipeParentId,
+
+    /// The optional id of the parent of this recipe parent.
+    ///
+    /// This must not form a cycle.
+    #[schema(nullable = false)]
+    pub(crate) parent: Option<RecipeParentId>,
+
+    /// The name of the recipe parent.
+    ///
+    /// This should be globally unique, to make searching easier for the user.
+    pub(crate) name: String,
+
+    /// An optional description of this recipe parent.
+    #[schema(nullable = false)]
+    pub(super) description: Option<String>,
+}
+
+mk_id!(RecipeParentId and RecipeParentIdStub);
diff --git a/crates/rocie-server/src/storage/sql/unit.rs b/crates/rocie-server/src/storage/sql/unit.rs
index 8bbfe60..dc16e4c 100644
--- a/crates/rocie-server/src/storage/sql/unit.rs
+++ b/crates/rocie-server/src/storage/sql/unit.rs
@@ -41,7 +41,7 @@ pub(crate) struct Unit {
     pub(crate) unit_property: UnitPropertyId,
 }
 
-#[derive(ToSchema, Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(ToSchema, Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
 pub(crate) struct UnitAmount {
     #[schema(minimum = 0)]
     pub(crate) value: u32,