chore: Bump holochain version 0.3.0-beta-dev.48

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "holochain_scaffolding_cli"
-version = "0.3000.0-dev.6"
+version = "0.3000.0-dev.7"
 description = "CLI to easily generate and modify holochain apps"
 license = "CAL-1.0"
 homepage = "https://developer.holochain.org"
@@ -18,10 +18,10 @@ name = "holochain_scaffolding_cli"
 path = "src/lib.rs"
 
 [dependencies]
-holochain = { features = ["test_utils"], version = "0.3.0-beta-dev.45"}
-holochain_types = "0.3.0-beta-dev.40"
-holochain_util = { features = ["backtrace"], version = "0.3.0-beta-dev.6" }
-mr_bundle = "0.3.0-beta-dev.8"
+holochain = { features = ["test_utils"], version = "0.3.0-beta-dev.48"}
+holochain_types = "0.3.0-beta-dev.43"
+holochain_util = { features = ["backtrace"], version = "0.3.0-beta-dev.8" }
+mr_bundle = "0.3.0-beta-dev.10"
 
 dirs = "4.0.0"
 ignore = "0.4"

run_test.sh

@@ -36,7 +36,7 @@ setup_and_build_happ() {
   cleanup_tmp "$1"
 
   cd $TEMPLATE_PATH
-  hc-scaffold --template "$2" web-app "$1" --setup-nix true
+  hc-scaffold --template "$2" web-app "$1" --setup-nix true -F
   cd "$1"
 
   hc-scaffold dna forum
@@ -93,7 +93,7 @@ if [[ -n "$SCOPE" ]]; then
     rm -rf /tmp/holo-flake
     cd /tmp
 
-    hc-scaffold --template vue web-app holo-flake --setup-nix true
+    hc-scaffold --template vue web-app holo-flake --setup-nix true -F
     cd holo-flake
 
     nix develop --command bash -c "

src/scaffold/app/nix.rs

@@ -7,10 +7,10 @@ use std::process::{Command, Stdio};
 
 use crate::error::{ScaffoldError, ScaffoldResult};
 use crate::file_tree::*;
-use crate::versions::holochain_nix_version;
+use crate::versions;
 
 pub fn flake_nix(holo_enabled: bool) -> FileTree {
-    let holochain_nix_version = holochain_nix_version();
+    let holochain_nix_version = versions::HOLOCHAIN_NIX_VERSION;
 
     let holo_inputs = holo_enabled
         .then_some(

src/scaffold/entry_type/integrity.rs

@@ -1,7 +1,7 @@
 use convert_case::{Case, Casing};
 use itertools::Itertools;
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
+use quote::{format_ident, quote, ToTokens};
 use std::{ffi::OsString, path::PathBuf};
 
 use crate::error::{ScaffoldError, ScaffoldResult};
@@ -690,7 +690,7 @@ fn add_entry_type_to_validation_arms(
                             ));
                         }
                     };
-                    match original_app_entry { }
+                    match original_app_entry {}
                 }"#,
                                                                     )?;
                                                             }
@@ -816,9 +816,15 @@ fn add_entry_type_to_validation_arms(
                                                                             syn::parse_str::<
                                                                                 syn::Expr,
                                                                             >(
-                                                                                r#"match (app_entry, original_app_entry) {
-     _ => Ok(ValidateCallbackResult::Invalid("Original and updated entry types must be the same".to_string()))
- }"#,
+                                                                                r#"
+{
+    let original_action = must_get_action(action.clone().original_action_address)?
+        .action()
+        .to_owned();
+    let original_action = EntryCreationAction::try_from(original_action)
+        .map_err(|e| wasm_error!(e.to_string()))?;
+    match app_entry {}
+}"#,
                                                                             )?;
                                                                     }
 
@@ -829,9 +835,12 @@ fn add_entry_type_to_validation_arms(
                                                                         )
                                                                     {
                                                                         let new_arm: syn::Arm = syn::parse_str(
-                                                                             format!(
-"(EntryTypes::{pascal_entry_def_name}({snake_entry_def_name}), EntryTypes::{pascal_entry_def_name}(original_{snake_entry_def_name})) => 
-    validate_update_{snake_entry_def_name}(action, {snake_entry_def_name}, original_action, original_{snake_entry_def_name}),", 
+                                                                             format!(r#"
+EntryTypes::{pascal_entry_def_name}({snake_entry_def_name}) => {{
+    let original_app_entry = must_get_valid_record(action.clone().original_action_address)?;
+    let original_{snake_entry_def_name} = {pascal_entry_def_name}::try_from(original_app_entry)?;
+    validate_update_{snake_entry_def_name}(action, {snake_entry_def_name}, original_action, original_{snake_entry_def_name})
+}}"#, 
                                                                             ).as_str()
                                                                         )?;
                                                                         entry_type_match
@@ -846,54 +855,62 @@ fn add_entry_type_to_validation_arms(
                                             } else if path_segment_str
                                                 .eq(&String::from("RegisterDelete"))
                                             {
-                                                if let Some(op_entry_match_expr) =
-                                                    find_ending_match_expr(&mut arm.body)
-                                                {
-                                                    for op_entry_arm in
-                                                        &mut op_entry_match_expr.arms
-                                                    {
-                                                        if let syn::Pat::Struct(pat_struct) =
-                                                            &mut op_entry_arm.pat
-                                                        {
-                                                            if let Some(ps) =
-                                                                pat_struct.path.segments.last()
-                                                            {
-                                                                if ps
-                                                                    .ident
-                                                                    .to_string()
-                                                                    .eq(&String::from("Entry"))
-                                                                {
-                                                                    // Add new entry type to match arm
-                                                                    if find_ending_match_expr(
-                                                                        &mut op_entry_arm.body,
-                                                                    )
-                                                                    .is_none()
-                                                                    {
-                                                                        // Change empty invalid to match on entry_type
-                                                                        *op_entry_arm.body = syn::parse_str::<syn::Expr>("match original_app_entry {}")?;
-                                                                    }
-                                                                    // Add new entry type to match arm
-                                                                    if let Some(entry_type_match) =
-                                                                        find_ending_match_expr(
-                                                                            &mut op_entry_arm.body,
-                                                                        )
-                                                                    {
-                                                                        let new_arm: syn::Arm = syn::parse_str(
-                                                                            format!("EntryTypes::{}({}) => validate_delete_{}(action, original_action, {}),", 
-                                                                                entry_def.name.to_case(Case::Pascal),
-                                                                                entry_def.name.to_case(Case::Snake),
-                                                                                entry_def.name.to_case(Case::Snake),
-                                                                                entry_def.name.to_case(Case::Snake)
-                                                                            ).as_str()
-                                                                        )?;
-                                                                        entry_type_match
-                                                                            .arms
-                                                                            .push(new_arm);
-                                                                    }
+                                                if arm.body.as_ref().to_token_stream().to_string().contains("There are no entry types in this integrity zome") {
+                                                    *arm.body = syn::parse_str::<syn::Expr>(r#"{
+                                                        let original_action_hash = delete_entry.clone().action.deletes_address;
+                                                        let original_record = must_get_valid_record(original_action_hash)?;
+                                                        let original_action = original_record.action().clone();
+                                                        let original_action = EntryCreationAction::try_from(original_action)
+                                                            .map_err(|e| wasm_error!(e.to_string()))?;
+                                                        let app_entry_type = match original_action.entry_type() {
+                                                            EntryType::App(app_entry_type) => app_entry_type,
+                                                            _ => {
+                                                                return Ok(ValidateCallbackResult::Valid);
+                                                            }
+                                                        };
+                                                        let entry = match original_record.entry().as_option() {
+                                                            Some(entry) => entry,
+                                                            None => {
+                                                                if original_action.entry_type().visibility().is_public() {
+                                                                    return Ok(ValidateCallbackResult::Invalid(
+                                                                        "Original record for a delete of a public entry must contain an entry"
+                                                                            .to_string(),
+                                                                    ));
+                                                                } else {
+                                                                    return Ok(ValidateCallbackResult::Valid);
                                                                 }
                                                             }
-                                                        }
-                                                    }
+                                                        };
+                                                        let original_app_entry = match EntryTypes::deserialize_from_type(
+                                                            app_entry_type.zome_index,
+                                                            app_entry_type.entry_index,
+                                                            entry,
+                                                        )? {
+                                                            Some(app_entry) => app_entry,
+                                                            None => {
+                                                                return Ok(ValidateCallbackResult::Invalid(
+                                                                    "Original app entry must be one of the defined entry types for this zome"
+                                                                        .to_string(),
+                                                                ));
+                                                            }
+                                                        };
+                                                        match original_app_entry {}
+                                                    }"#,
+                                                   )?;
+                                                }
+
+                                                // Add new entry type to match arm
+                                                if let Some(match_expr) =
+                                                    find_ending_match_expr(&mut arm.body)
+                                                {
+                                                    let new_arm: syn::Arm = syn::parse_str(
+                                                  format!(r#"
+EntryTypes::{pascal_entry_def_name}(original_{snake_entry_def_name}) => {{
+    validate_delete_{snake_entry_def_name}(delete_entry.clone().action, original_action, original_{snake_entry_def_name})
+}}"#, 
+                                                 ).as_str()
+                                             )?;
+                                                    match_expr.arms.insert(0, new_arm);
                                                 }
                                             }
                                         }

src/scaffold/zome.rs

@@ -15,7 +15,7 @@ use crate::{
         integrity::scaffold_integrity_zome_templates, ScaffoldedTemplate,
     },
     utils::input_with_case,
-    versions::{hdi_version, hdk_version},
+    versions,
 };
 use build_fs_tree::{dir, file};
 use holochain_types::prelude::{DnaManifest, ZomeManifest};
@@ -334,10 +334,16 @@ fn try_to_guess_coordinator_zomes_location(
 pub fn add_common_zome_dependencies_to_workspace_cargo(
     file_tree: FileTree,
 ) -> ScaffoldResult<FileTree> {
-    let file_tree =
-        add_workspace_external_dependency(file_tree, "hdi", &format!("={}", hdi_version()))?;
-    let file_tree =
-        add_workspace_external_dependency(file_tree, "hdk", &format!("={}", hdk_version()))?;
+    let file_tree = add_workspace_external_dependency(
+        file_tree,
+        "hdi",
+        &format!("={}", versions::HDI_VERSION),
+    )?;
+    let file_tree = add_workspace_external_dependency(
+        file_tree,
+        "hdk",
+        &format!("={}", versions::HDK_VERSION),
+    )?;
     let file_tree = add_workspace_external_dependency(file_tree, "serde", "1.0")?;
     Ok(file_tree)
 }

src/scaffold/zome/integrity.rs

@@ -74,45 +74,33 @@ pub fn validate(op: Op) -> ExternResult<ValidateCallbackResult> {
             _ => Ok(ValidateCallbackResult::Valid)
         },
         FlatOp::RegisterUpdate(update_entry) => match update_entry {
-            OpUpdate::Entry {
-                original_action,
-                original_app_entry,
-                app_entry,
-                action
-            } => Ok(ValidateCallbackResult::Invalid(
-                "There are no entry types in this integrity zome".to_string(),
-            )),
+            OpUpdate::Entry { app_entry, action } => {
+                Ok(ValidateCallbackResult::Invalid(
+                    "There are no entry types in this integrity zome".to_string(),
+                ))
+            },
             _ => Ok(ValidateCallbackResult::Valid)
         },
-        FlatOp::RegisterDelete(delete_entry) => match delete_entry {
-            OpDelete::Entry {
-                original_action,
-                original_app_entry,
-                action
-            } => Ok(ValidateCallbackResult::Invalid(
-                "There are no entry types in this integrity zome".to_string(),
-            )),
-            _ => Ok(ValidateCallbackResult::Valid),
-        },
+        FlatOp::RegisterDelete(delete_entry) => Ok(ValidateCallbackResult::Invalid(
+            "There are no entry types in this integrity zome".to_string(),
+        )),
         FlatOp::RegisterCreateLink {
             link_type,
             base_address,
             target_address,
             tag,
             action
-        } => Ok(ValidateCallbackResult::Invalid(String::from(
-            "There are no link types in this integrity zome",
-        ))),
+        } => Ok(ValidateCallbackResult::Invalid(
+            "There are no link types in this integrity zome".to_string()
+        )),
         FlatOp::RegisterDeleteLink {
             link_type,
             base_address,
             target_address,
             tag,
             original_action,
             action
-        } => Ok(ValidateCallbackResult::Invalid(String::from(
-            "There are no link types in this integrity zome",
-        ))),
+        } => Ok(ValidateCallbackResult::Invalid("There are no link types in this integrity zome".to_string())),
         FlatOp::StoreRecord(store_record) => match store_record {
             /// Complementary validation to the `StoreEntry` Op, in which the record itself is validated
             /// If you want to optimize performance, you can remove the validation for an entry type here and keep it in `StoreEntry`