* MS new claim-gen/junto importer works without error, on the four contemporary json-export examples.

* MS if the "addNodeLink" gql command fails, it returns the text of the parent and child nodes, to help the caller know where the problem was. (shouldn't be a security concern, since the database transaction has row-level-security enabled)
* MS if an error occurs during the parsing/interpretation of a JSON blob put into the subtree-importer dialog, the error is caught and displayed in the UI. (rather than causing a wider UI error, that eg. can break the nav-bar)

Author: Venryx

.vscode/settings.json

@@ -20,7 +20,31 @@
 
 	"[rust]": {
 		"editor.defaultFormatter": "rust-lang.rust-analyzer",
-		"editor.formatOnSave": true
+
+		// 2025-06-06: this adds too much (often >1s) delay before save completes
+		//"editor.formatOnSave": true,
+
+		// 2025-06-06: tried this, but seems to just never do formatting
+		/*"editor.formatOnSave": true,
+		"editor.formatOnSaveMode": "modificationsIfAvailable",*/
+
+		// 2025-06-06: decided to add a custom hotkey instead (user-level keybindings.json), which explicitly does a save-all operation THEN a format operation, IF the file is a Rust file
+		/*{
+			"key": "ctrl+s",
+			"command": "runCommands", 
+			"when": "editorLangId == rust",
+			"args": {
+				"commands": [
+					"workbench.action.files.saveAll",
+					"editor.action.formatDocument",
+				]
+			}
+		},
+		{
+			"key": "ctrl+s",
+			"command": "workbench.action.files.saveAll",
+			"when": "editorLangId != rust"
+		},*/
   	},
 	"rust-analyzer.server.extraEnv": {
 		// this allows us to use unstable features (as is true for the Docker builds), without rust-analyzer showing an error on the "#![feature(XXX)]" line
@@ -38,7 +62,7 @@
 	},
 	//"rust-analyzer.checkOnSave.enable": false,
 	// have RA's cargo-check use a separate cache-directory (otherwise, eg. running cargo-check in terminal with different flags will mess up RA's cargo-check cache, requiring a full re-check for RA)
-	"rust-analyzer.checkOnSave.extraArgs": [
+	"rust-analyzer.check.extraArgs": [
 		"--target-dir", "./Temp/rust-analyzer-check"
 	],
 	// maybe use these in the future, in place of the "-Awarnings" flag in config.toml and Dockerfile

Packages/app-server/src/db/commands/_temp/clone_map_special.rs

@@ -21,7 +21,7 @@ use crate::db::commands::add_map::{add_map, AddMapInput};
 use crate::db::general::sign_in_::jwt_utils::{get_user_info_from_gql_ctx, resolve_jwt_to_user_info};
 use crate::db::maps::{get_map, MapInput};
 use crate::db::node_links::{get_node_links, ChildGroup, NodeLinkInput};
-use crate::db::node_phrasings::NodePhrasing_Embedded;
+use crate::db::node_phrasings::{get_first_non_empty_text_in_phrasing, get_first_non_empty_text_in_phrasing_embedded, NodePhrasing_Embedded};
 use crate::db::node_revisions::{get_node_revision, NodeRevision, NodeRevisionInput};
 use crate::db::nodes::{get_node, get_node_children};
 use crate::db::nodes_::_node::{Node, NodeInput};
@@ -180,20 +180,7 @@ pub fn clone_node_tree_special<'a>(ctx: &'a AccessorContext<'_>, actor: &'a User
 				let grandchild_links = get_node_links(ctx, Some(child.id.as_str()), None).await?;
 				let has_attachments = child_rev.attachments.len() > 0;
 				// ensure that argument has no title, in any of the text_XXX fields
-				let get_if_non_empty = |s: &Option<String>| {
-					match s {
-						Some(s) => match s {
-							s if s.is_empty() => None,
-							_ => Some(s.to_owned()),
-						},
-						None => None,
-					}
-				};
-				let first_non_empty_title =
-					get_if_non_empty(&Some(child_rev.phrasing.text_base.clone()))
-					.or(get_if_non_empty(&child_rev.phrasing.text_negation.clone()))
-					.or(get_if_non_empty(&child_rev.phrasing.text_question.clone()))
-					.or(get_if_non_empty(&child_rev.phrasing.text_narrative.clone()));
+				let first_non_empty_title = get_first_non_empty_text_in_phrasing_embedded(&child_rev.phrasing);
 				/*if let Some(title) = first_non_empty_title {
 					warn!("Argument node #{} has a non-empty title. If this is a dry-run, it's recommended to investigate these entries before proceeding. @title:\n\t{}", child.id.as_str(), title);
 				}*/

Packages/app-server/src/db/commands/add_node_link.rs

@@ -5,6 +5,7 @@ use rust_shared::db_constants::{GLOBAL_ROOT_NODE_ID, SYSTEM_USER_ID};
 use rust_shared::rust_macros::wrap_slow_macros;
 use rust_shared::serde::{Deserialize, Serialize};
 use rust_shared::serde_json::{json, Value};
+use rust_shared::utils::general_::extensions::ToOwnedV;
 use rust_shared::utils::time::time_since_epoch_ms_i64;
 use rust_shared::utils::type_aliases::JSONValue;
 use rust_shared::{anyhow, async_graphql, serde_json, GQLError};
@@ -20,6 +21,8 @@ use crate::db::general::permission_helpers::assert_user_can_add_child;
 use crate::db::general::sign_in_::jwt_utils::{get_user_info_from_gql_ctx, resolve_jwt_to_user_info};
 use crate::db::node_links::{get_node_links, ChildGroup, NodeLink, NodeLinkInput, Polarity};
 use crate::db::node_links_::node_link_validity::assert_new_link_is_valid;
+use crate::db::node_phrasings::get_first_non_empty_text_in_phrasing_embedded;
+use crate::db::node_revisions::get_node_revision;
 use crate::db::nodes::get_node;
 use crate::db::nodes_::_node::Node;
 use crate::db::nodes_::_node_type::{get_node_type_info, NodeType};
@@ -86,7 +89,12 @@ pub async fn add_node_link(ctx: &AccessorContext<'_>, actor: &User, _is_root: bo
 		/*let parent_to_child_links = get_node_links(ctx, Some(&parent_id), Some(&child_id)).await?;
 		ensure!(parent_to_child_links.len() == 0, "Node #{child_id} is already a child of node #{parent_id}.");*/
 
-		assert_new_link_is_valid(ctx, &parent_id, &link.child, link.c_childType, link.group, link.polarity, Some(actor)).await?;
+		if let Err(err) = assert_new_link_is_valid(ctx, &parent_id, &link.child, link.c_childType, link.group, link.polarity, Some(actor)).await {
+			let parent_text = get_first_non_empty_text_in_phrasing_embedded(&get_node_revision(ctx, &parent.c_currentRevision).await?.phrasing);
+			let child_text = get_first_non_empty_text_in_phrasing_embedded(&get_node_revision(ctx, &child.c_currentRevision).await?.phrasing);
+			let link_json = serde_json::to_string(&link).unwrap_or_else(|_| "<failed to serialize link>".o());
+			return Err(err.context(format!("New link is invalid. @parent_text({parent_text:?}) @childText({child_text:?}) @link({link_json})")).into());
+		}
 	}
 
 	upsert_db_entry_by_id_for_struct(&ctx, "nodeLinks".to_owned(), link.id.to_string(), link.clone()).await?;

Packages/app-server/src/db/node_phrasings.rs

@@ -37,6 +37,32 @@ pub async fn get_node_phrasings(ctx: &AccessorContext<'_>, node_id: &str) -> Res
     }))).await
 }
 
+fn get_if_non_empty(s: Option<&str>) -> Option<String> {
+	match s {
+		Some(s) => match s {
+			s if s.is_empty() => None,
+			_ => Some(s.to_owned()),
+		},
+		None => None, //hi23233223232234234234234234234234234
+	}
+}
+#[rustfmt::skip]
+pub fn get_first_non_empty_text_in_phrasing(phrasing: &NodePhrasing) -> Option<String> {
+	let first_non_empty_title = get_if_non_empty(Some(&phrasing.text_base))
+		.or(get_if_non_empty(phrasing.text_negation.as_deref()))
+		.or(get_if_non_empty(phrasing.text_question.as_deref()))
+		.or(get_if_non_empty(phrasing.text_narrative.as_deref()));
+	first_non_empty_title
+}
+#[rustfmt::skip]
+pub fn get_first_non_empty_text_in_phrasing_embedded(phrasing: &NodePhrasing_Embedded) -> Option<String> {
+	let first_non_empty_title = get_if_non_empty(Some(&phrasing.text_base))
+		.or(get_if_non_empty(phrasing.text_negation.as_deref()))
+		.or(get_if_non_empty(phrasing.text_question.as_deref()))
+		.or(get_if_non_empty(phrasing.text_narrative.as_deref()));
+	first_non_empty_title
+}
+
 wrap_slow_macros! {
 
 #[derive(Enum, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]

Packages/client/Source/UI/@Shared/Maps/Node/NodeUI_Menu/MI_ImportSubtree.tsx

@@ -10,7 +10,7 @@ import {apolloClient} from "Utils/LibIntegrations/Apollo.js";
 import {liveSkin} from "Utils/Styles/SkinManager.js";
 import {AddNotificationMessage, ES, InfoButton, O, Observer, P, RunInAction_Set, UseWindowEventListener} from "web-vcore";
 import {gql} from "@apollo/client";
-import {E, FromJSON, GetEntries, ModifyString, SleepAsync, Timer} from "js-vextensions";
+import {E, FromJSON, GetEntries, GetStackTraceStr, ModifyString, SleepAsync, Timer} from "js-vextensions";
 import {makeObservable} from "mobx";
 import {ignore} from "mobx-sync";
 import {Button, CheckBox, Column, Row, Select, Spinner, Text, TextArea} from "react-vcomponents";
@@ -128,7 +128,7 @@ class ImportSubtreeUI extends BaseComponent<
 		selectFromIndex: number,
 		searchQueryGen: number,
 	},
-	{resources: ImportResource[]}
+	{resources: ImportResource[], resources_parseError: Error|n}
 > {
 	static initialState: Partial<ExtractState<ImportSubtreeUI>> = {
 		leftTab: ImportSubtreeUI_LeftTab.source,
@@ -156,25 +156,31 @@ class ImportSubtreeUI extends BaseComponent<
 		const importContext = useMemo(()=>({mapID: map.id, nodeAccessPolicyID}), [map.id, nodeAccessPolicyID]);
 
 		let resources: ImportResource[] = [];
+		let resources_parseError: Error|n;
 		if (process) {
-			if (uiState.sourceType == DataExchangeFormat.json_dm && forJSONDM_subtreeData != null) {
-				resources = GetResourcesInImportSubtree_JsonDm(forJSONDM_subtreeData, node);
-			} else if (uiState.sourceType == DataExchangeFormat.json_dm_fs && forJSONDMFS_subtreeData != null) {
-				resources = GetResourcesInImportSubtree_JsonDmFs(forJSONDMFS_subtreeData);
-			} else if (uiState.sourceType == DataExchangeFormat.json_cg && forJSONCG_subtreeData != null) {
-				resources = GetResourcesInImportSubtree_CG(importContext, forJSONCG_subtreeData);
-			} else if (uiState.sourceType == DataExchangeFormat.csv_sl && forCSVSL_subtreeData != null) {
-				resources = GetResourcesInImportSubtree_CSV_SL(forCSVSL_subtreeData);
-			}
-			if (uiState.accessPolicyOverride != null) {
-				for (const resource of resources) {
-					if (resource instanceof IR_NodeAndRevision) {
-						resource.node.accessPolicy = uiState.accessPolicyOverride;
+			try {
+				if (uiState.sourceType == DataExchangeFormat.json_dm && forJSONDM_subtreeData != null) {
+					resources = GetResourcesInImportSubtree_JsonDm(forJSONDM_subtreeData, node);
+				} else if (uiState.sourceType == DataExchangeFormat.json_dm_fs && forJSONDMFS_subtreeData != null) {
+					resources = GetResourcesInImportSubtree_JsonDmFs(forJSONDMFS_subtreeData);
+				} else if (uiState.sourceType == DataExchangeFormat.json_cg && forJSONCG_subtreeData != null) {
+					resources = GetResourcesInImportSubtree_CG(importContext, forJSONCG_subtreeData);
+				} else if (uiState.sourceType == DataExchangeFormat.csv_sl && forCSVSL_subtreeData != null) {
+					resources = GetResourcesInImportSubtree_CSV_SL(forCSVSL_subtreeData);
+				}
+				if (uiState.accessPolicyOverride != null) {
+					for (const resource of resources) {
+						if (resource instanceof IR_NodeAndRevision) {
+							resource.node.accessPolicy = uiState.accessPolicyOverride;
+						}
 					}
 				}
+			} catch (ex) {
+				resources_parseError = ex as Error;
+				console.error("Error while processing import-subtree data:", ex);
 			}
 		}
-		this.Stash({resources});
+		this.Stash({resources, resources_parseError});
 
 		const selectedIRs_nodeAndRev = [...uiState.selectedImportResources].filter(a=>a instanceof IR_NodeAndRevision) as IR_NodeAndRevision[];
 		const selectedIRs_nodeAndRev_importedSoFar = selectedIRs_nodeAndRev_atImportStart - selectedIRs_nodeAndRev.length;
@@ -283,14 +289,7 @@ class ImportSubtreeUI extends BaseComponent<
 									} else if (uiState.sourceType == DataExchangeFormat.json_cg) {
 										let subtreeData_new: CG_Node|n = null;
 										try {
-											const rawData = FromJSON(newSourceText);
-											if ("questions" in rawData) {
-												subtreeData_new = rawData as CG_Node;
-											} else if ("positions" in rawData) {
-												subtreeData_new = {
-													questions: [rawData],
-												} as CG_Node;
-											}
+											subtreeData_new = FromJSON(newSourceText);
 											newState.forJSONCG_subtreeData = subtreeData_new;
 											newState.sourceText_parseError = null;
 										} catch (err) {
@@ -403,6 +402,8 @@ class ImportSubtreeUI extends BaseComponent<
 								</PolicyPicker>
 							</Row>
 							<ScrollView>
+								{resources_parseError != null &&
+								<Text mt={5} sel style={{color: "red", whiteSpace: "pre-wrap"}}>Error while processing import-subtree data: {resources_parseError.stack ?? resources_parseError.toString()}</Text>}
 								<ReactList type="variable" length={resources.length}
 									itemRenderer={this.RenderResource}
 									itemSizeEstimator={this.EstimateResourceUIHeight}/>

Packages/client/Source/Utils/DataFormats/JSON/ClaimGen/DataModel.ts

@@ -1,6 +1,7 @@
 import {Attachment, AttachmentType, DescriptionAttachment, NodeType, QuoteAttachment, ReferencesAttachment, Source, SourceChain, SourceType} from "dm_common";
 import {Assert, IsString} from "js-vextensions";
 
+export const CG_Node_keysForChildrenObjects: Array<keyof CG_Node> = ["positions", "categories", "claims", "arguments"] as const;
 export class CG_Node {
 	constructor(data: Partial<CG_Node>, _isSyntheticNodeObj_fromStringCollection: "atomic_claims" | "counter_claims" | "examples") {
 		Object.assign(this, data, {_isSyntheticNodeObj_fromStringCollection});
@@ -21,7 +22,15 @@ export class CG_Node {
 			if (node._isSyntheticNodeObj_fromStringCollection == "counter_claims") return NodeType.claim;
 			if (node._isSyntheticNodeObj_fromStringCollection == "examples") return NodeType.claim;
 		}
-		throw new Error("Cannot discern node-type for CG_Node: " + JSON.stringify(node));
+
+		console.warn("Cannot discern node-type for CG_Node, so using fallback node-type of category. @data: " + JSON.stringify(node, function(key, value) {
+			// for children-object collections, just show the number of children, to avoid cluttering the error message
+			if (CG_Node_keysForChildrenObjects.includes(key as any) && Array.isArray(value)) {
+				return `<children count: ${value.length}; actual json omitted for brevity>`;
+			}
+			return value;
+		}, "\t"));
+		return NodeType.category; // fallback node-type (can happen for claim-gen exports that are just a "root node" with an "arguments" children-collection, but no text or anything for that root container-node)
 	}
 
 	// special fields (added by importer itself, during interpretation process)

Packages/client/Source/Utils/DataFormats/JSON/ClaimGen/ImportHelpers.ts

@@ -9,24 +9,24 @@ export class ImportContext {
 }
 
 export const GetResourcesInImportSubtree_CG = CreateAccessor((context: ImportContext, rootNode: CG_Node)=>{
-	return GetResourcesInImportNode_CG(context, rootNode, [], [], null);
+	return GetResourcesInImportNode_CG(context, rootNode, [0], [CG_Node.GetText(rootNode)], null, null);
 });
-export const GetResourcesInImportNode_CG = CreateAccessor((context: ImportContext, node: CG_Node, path_indexes: number[], path_titles: string[], parentResource: ImportResource|n)=>{
+export const GetResourcesInImportNode_CG = CreateAccessor((context: ImportContext, node: CG_Node, path_indexes: number[], path_titles: string[], parentResource: ImportResource|n, parentNode: CG_Node|n)=>{
 	const result = [] as ImportResource[];
 
 	// own node
-	const ownResource = NewNodeResource(context, node, path_indexes, path_titles, parentResource);
+	const ownResource = NewNodeResource(context, node, path_indexes, path_titles, parentResource, parentNode);
 	result.push(ownResource);
 
 	// children nodes
 	for (const [i, child] of CG_Node.GetChildren(node).entries()) {
-		result.push(...GetResourcesInImportNode_CG(context, child, path_indexes.concat(i), path_titles.concat(CG_Node.GetText(child)), ownResource));
+		result.push(...GetResourcesInImportNode_CG(context, child, path_indexes.concat(i), path_titles.concat(CG_Node.GetText(child)), ownResource, node));
 	}
 
 	return result;
 });
 
-export const NewNodeResource = CreateAccessor((context: ImportContext, data: CG_Node, path_indexes: number[], path_titles: string[], parentResource: ImportResource|n)=>{
+export const NewNodeResource = CreateAccessor((context: ImportContext, data: CG_Node, path_indexes: number[], path_titles: string[], parentResource: ImportResource|n, parentData: CG_Node|n)=>{
 	const nodeType = CG_Node.GetNodeType(data);
 	const node = new NodeL1({
 		type: nodeType,
@@ -39,7 +39,7 @@ export const NewNodeResource = CreateAccessor((context: ImportContext, data: CG_
 		orderKey = orderKey.next();
 	}
 	const link = new NodeLink({
-		group: ChildGroup.generic,
+		group: parentData && CG_Node.GetNodeType(parentData) == NodeType.claim ? ChildGroup.freeform : ChildGroup.generic,
 		orderKey: orderKey.toString(),
 		//form: claimForm,
 	});