@voxgig/sdkgen 4.34.0 → 4.34.1

package/project/.sdk/src/cmp/rust/ReadmeTopTest_rust.ts

@@ -33,7 +33,7 @@ const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
 
   Content(`\`\`\`rust
-use ${rustcrate}::{jo, test_sdk, Value};
+use ${rustcrate}::{jo, test_sdk, ${model.const.Name}Entity, Entity, Value};
 
 let client = test_sdk(Value::Noval, Value::Noval);
 `)
@@ -55,7 +55,7 @@ let client = test_sdk(Value::Noval, Value::Noval);
         ? `jo(vec![${items.map((it: any) =>
           `("${it.name}", ${it.name === idF ? 'Value::str("test01")' : rustLit(it.type)})`).join(', ')}])`
         : 'Value::Noval'
-    } else if ('create' === primaryOp || 'update' === primaryOp) {
+    } else if ('create' === primaryOp || 'update' === primaryOp || 'patch' === primaryOp) {
       const items = opRequestShape(exampleEntity, primaryOp).items
         .filter((it: any) => it.name !== idF && it.name !== 'id')
       const required = items.filter((it: any) => !it.optional)
@@ -64,10 +64,18 @@ let client = test_sdk(Value::Noval, Value::Noval);
         ? `jo(vec![${chosen.map((it: any) => `("${it.name}", ${rustLit(it.type)})`).join(', ')}])`
         : 'Value::empty_map()'
     }
-    const eVar = rustVarName(exampleEntity.name) + ('list' === primaryOp ? 's' : '')
-    Content(`let ${eVar} = client.${method}(Value::Noval).${primaryOp}(${arg}, Value::Noval).unwrap();
-println!("{:?}", ${eVar});
+    const eVar = rustVarName(exampleEntity.name)
+    if ('list' === primaryOp) {
+      Content(`for ${eVar} in client.${method}(Value::Noval).list(${arg}, Value::Noval).unwrap() {
+    println!("{:?}", ${eVar}.data(None));
+}
+`)
+    }
+    else {
+      Content(`let ${eVar} = client.${method}(Value::Noval).${primaryOp}(${arg}, Value::Noval).unwrap();
+println!("{:?}", ${eVar}.data(None));
 `)
+    }
   }
 
   Content(`\`\`\`

package/project/.sdk/src/cmp/rust/TestClean_rust.ts

@@ -21,7 +21,7 @@ import { rustMethodName } from './utility_rust'
 
 
 // A custom action is not a trait method the sweep can call by name.
-const CRUD = ['list', 'load', 'create', 'update', 'remove']
+const CRUD = ['list', 'load', 'create', 'update', 'patch', 'remove']
 
 const DIAGNOSTIC = ['log', 'debug', 'audit', 'telemetry', 'cost', 'metrics', 'clienttrack']
 
@@ -100,16 +100,18 @@ function render(spec: {
   const { Name, rustcrate, auth, features, candidates } = spec
 
   const drivers = candidates.map((c) => 'list' === c.op
-    ? `fn ${c.fn}(sdk: &Rc<${Name}SDK>, mtch: Value, ctrl: Value) -> Result<Value, ${Name}Error> {
-    sdk.${c.method}(Value::Noval)
+    ? `fn ${c.fn}(sdk: &Rc<${Name}SDK>, mtch: Value, ctrl: Value) -> (Result<Value, ${Name}Error>, Value) {
+    let ent = sdk.${c.method}(Value::Noval);
+    let out = ent
         .list(mtch, ctrl)
-        .map(|items| Value::list(items.iter().map(|e| e.data(None)).collect()))
+        .map(|items| Value::list(items.iter().map(|e| e.data(None)).collect()));
+    (out, ent.matchv(None))
 }
 `
-    : `fn ${c.fn}(sdk: &Rc<${Name}SDK>, mtch: Value, ctrl: Value) -> Result<Value, ${Name}Error> {
-    sdk.${c.method}(Value::Noval)
-        .${c.op}(mtch, ctrl)
-        .map(|e| e.data(None))
+    : `fn ${c.fn}(sdk: &Rc<${Name}SDK>, mtch: Value, ctrl: Value) -> (Result<Value, ${Name}Error>, Value) {
+    let ent = sdk.${c.method}(Value::Noval);
+    let out = ent.${c.op}(mtch, ctrl).map(|e| e.data(None));
+    (out, ent.matchv(None))
 }
 `).join('\n') + '\n' + candidates.map((c) =>
     `fn ${c.sfn}(sdk: &Rc<${Name}SDK>, mtch: Value, callopts: Value) -> Result<Vec<Value>, ${Name}Error> {
@@ -412,11 +414,45 @@ fn transport(scenario: Scenario) -> Value {
     })
 }
 
+// Offline, as every generated suite is: the test OPTION resolves a required
+// server variable to test-<name>, and installs no transport.
+fn offline(opts: Value) -> Value {
+    setp(&opts, "test", jo(vec![("active", Value::Bool(true))]));
+    opts
+}
+
+// A client the sweep cannot build leaves nothing swept: a harness error, not
+// a leak.
+fn construct(opts: Value) -> Rc<${Name}SDK> {
+    let opts = offline(opts);
+    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| ${Name}SDK::new(opts))) {
+        Ok(sdk) => sdk,
+        Err(cause) => panic!(
+            "clean harness: the client could not be constructed, so nothing was swept: {}",
+            cause
+                .downcast_ref::<String>()
+                .cloned()
+                .or_else(|| cause.downcast_ref::<&str>().map(|s| s.to_string()))
+                .unwrap_or_default()
+        ),
+    }
+}
+
 fn make_sdk(
     scenario: Scenario,
     sinks: &Sinks,
     cleanopts: Option<Value>,
     extra: Vec<FeatureRef>,
+) -> Rc<${Name}SDK> {
+    make_sdk_with(scenario, sinks, cleanopts, extra, None)
+}
+
+fn make_sdk_with(
+    scenario: Scenario,
+    sinks: &Sinks,
+    cleanopts: Option<Value>,
+    extra: Vec<FeatureRef>,
+    auth: Option<Value>,
 ) -> Rc<${Name}SDK> {
     let feature = Value::empty_map();
     for name in FEATURES {
@@ -439,14 +475,18 @@ fn make_sdk(
         }
     }
 
-    let sdk = ${Name}SDK::new(jo(vec![
+    let opts = jo(vec![
         ("apikey", Value::str(CANARY_APIKEY)),
         ("secret", Value::str(CANARY_SECRET)),
         ("headers", jo(vec![("X-Custom-Token", Value::str(CANARY_HEADER))])),
         ("clean", clean),
         ("feature", feature),
         ("system", jo(vec![("fetch", transport(scenario))])),
-    ]));
+    ]);
+    if let Some(auth) = auth {
+        setp(&opts, "auth", auth);
+    }
+    let sdk = construct(opts);
 
     // Rust options are pure data, so the extension feature is added after
     // construction (the \`extend\` option of the ts client).
@@ -457,7 +497,8 @@ fn make_sdk(
     sdk
 }
 
-type Drive = fn(&Rc<${Name}SDK>, Value, Value) -> Result<Value, ${Name}Error>;
+// What the operation returned, and the match its entity then holds.
+type Drive = fn(&Rc<${Name}SDK>, Value, Value) -> (Result<Value, ${Name}Error>, Value);
 type Stream = fn(&Rc<${Name}SDK>, Value, Value) -> Result<Vec<Value>, ${Name}Error>;
 
 ${drivers}
@@ -477,7 +518,7 @@ struct Target {
 // The first operation that completes against a plain 200: with no
 // arguments, else with every path parameter its points declare filled in.
 fn usable_op() -> Option<Target> {
-    let plain = ${Name}SDK::new(jo(vec![
+    let plain = construct(jo(vec![
         ("apikey", Value::str(CANARY_APIKEY)),
         ("system", jo(vec![("fetch", transport(Scenario::Ok))])),
     ]));
@@ -487,7 +528,7 @@ fn usable_op() -> Option<Target> {
             setp(&filled, p, Value::str("p1"));
         }
         for mtch in [Value::empty_map(), filled] {
-            if drive(&plain, vs::clone(&mtch), Value::Noval).is_ok() {
+            if drive(&plain, vs::clone(&mtch), Value::Noval).0.is_ok() {
                 return Some(Target { drive: *drive, stream: *stream, mtch });
             }
         }
@@ -508,7 +549,8 @@ fn same_node(a: &Value, b: &Value) -> bool {
 fn drive(sdk: &Rc<${Name}SDK>, target: &Target, ctrl: Value, sinks: &Sinks) -> Option<${Name}Error> {
     // A caller may keep the record it passed rather than read ctrl.explain.
     let held = getp(&ctrl, "explain");
-    let out = match (target.drive)(sdk, vs::clone(&target.mtch), ctrl.clone()) {
+    let (res, mtch) = (target.drive)(sdk, vs::clone(&target.mtch), ctrl.clone());
+    let out = match res {
         Ok(out) => {
             push_value(sinks, "result", &out);
             None
@@ -518,6 +560,8 @@ fn drive(sdk: &Rc<${Name}SDK>, target: &Target, ctrl: Value, sinks: &Sinks) -> O
             Some(err)
         }
     };
+    // Raw, as a caller copying the match into another query reads it.
+    push_value(sinks, "match", &mtch);
     let explain = getp(&ctrl, "explain");
     if let Value::Map(_) = explain {
         push_value(sinks, "explain", &explain);
@@ -581,14 +625,20 @@ fn clean_no_credential_leaves_the_sdk_in_any_form() {
         }
     }
 
+    // A name given at run time replaces the declared one: the match leaves
+    // out whichever name prepare_auth placed.
+    let renamed = make_sdk_with(Scenario::Ok, &sinks, None, Vec::new(),
+        Some(jo(vec![("name", Value::str("zzcred"))])));
+    drive(&renamed, &target, Value::Noval, &sinks);
+
     // A credential mistyped as a map. The rust validator does not reject it
     // (make_options keeps its input when validation fails), so what the
     // constructor produced is swept instead: the client's prints, and a
     // string quoting the value, cleaned the way a validation message is.
-    let mistyped = ${Name}SDK::new(jo(vec![
+    let mistyped = ${Name}SDK::new(offline(jo(vec![
         ("apikey", jo(vec![("value", Value::str(CANARY_APIKEY))])),
         ("clean", jo(vec![("values", Value::str(CANARY_VALUE))])),
-    ]));
+    ])));
     push(&sinks, "mistyped:debug", format!("{:?}", mistyped));
     push(&sinks, "mistyped:display", format!("{}", mistyped));
     push(
@@ -647,7 +697,7 @@ fn clean_no_credential_leaves_the_sdk_in_any_form() {
     push_error(&sinks, "stepped", &stepped);
 
     // A client given no clean block at all masks by the schema defaults.
-    let bare = ${Name}SDK::new(jo(vec![
+    let bare = construct(jo(vec![
         ("apikey", Value::str(CANARY_APIKEY)),
         ("secret", Value::str(CANARY_SECRET)),
         ("headers", jo(vec![("X-Custom-Token", Value::str(CANARY_HEADER))])),
@@ -769,7 +819,7 @@ fn clean_the_sweep_can_see_a_leak() {
 
 #[test]
 fn clean_masks_a_registered_value_used_as_a_name() {
-    let sdk = ${Name}SDK::new(jo(vec![(
+    let sdk = construct(jo(vec![(
         "clean",
         jo(vec![("values", Value::str("ZZVAL-abc123,ZZVAL-xyz789"))]),
     )]));
@@ -791,14 +841,15 @@ fn clean_masks_a_registered_value_used_as_a_name() {
 // A feature's name is not a field name: a feature called secrets does not
 // make its settings secret, though a sensitive field inside it still is. An
 // entity block, of per-entity settings or seeded records keyed by entity name
-// and id, is not read at all.
+// and id, is not read at all, and nor are rbac's rules, keyed by entity and
+// operation names.
 #[test]
 fn clean_reads_a_feature_name_as_a_name() {
     let seeded = jo(vec![(
         "zztoken",
         jo(vec![("ZZTOKEN01", jo(vec![("note", Value::str("PLAINRECORD-t5r3e1w9"))]))]),
     )]);
-    let sdk = ${Name}SDK::new(jo(vec![
+    let sdk = construct(jo(vec![
         ("apikey", Value::str(CANARY_APIKEY)),
         (
             "feature",
@@ -811,6 +862,13 @@ fn clean_reads_a_feature_name_as_a_name() {
                         ("token", Value::str("ZZTOKEN-feat456")),
                     ]),
                 ),
+                (
+                    "rbac",
+                    jo(vec![
+                        ("active", Value::Bool(false)),
+                        ("rules", jo(vec![("zztoken.load", Value::str("PLAINRULE-k7j5h3g1"))])),
+                    ]),
+                ),
                 ("test", jo(vec![("active", Value::Bool(false)), ("entity", seeded)])),
             ]),
         ),
@@ -829,11 +887,12 @@ fn clean_reads_a_feature_name_as_a_name() {
     );
     assert_eq!(clean::clean_str(&ctx, "record PLAINRECORD-t5r3e1w9"), "record PLAINRECORD-t5r3e1w9");
     assert_eq!(clean::clean_str(&ctx, "alias PLAINALIAS-m2n4b6v8"), "alias PLAINALIAS-m2n4b6v8");
+    assert_eq!(clean::clean_str(&ctx, "rule PLAINRULE-k7j5h3g1"), "rule PLAINRULE-k7j5h3g1");
 }
 
 #[test]
 fn clean_honours_the_generated_config_clean_block() {
-    let utility = ${Name}SDK::new(Value::empty_map()).get_utility();
+    let utility = construct(Value::empty_map()).get_utility();
     let config = jo(vec![(
         "options",
         jo(vec![(

package/project/.sdk/src/cmp/rust/TestDirect_rust.ts

@@ -15,12 +15,28 @@ import {
   serverVarEnv,
   serverVariables,
   pointParts,
+  liveStrict,
+  liveStrictNote,
 } from '@voxgig/sdkgen'
 
 
 import { rustVarName } from './utility_rust'
 
 
+// Blocked without the ids its request needs, rather than sent without them.
+function liveKeysBlock(keys: string[], entidEnvVar: string): string {
+  return 0 === keys.length ? '' : `    if setup.live {
+        for live_key in [${keys.map((k) => JSON.stringify(k)).join(', ')}] {
+            if getp(&setup.idmap, live_key).is_noval() {
+                live_miss(LIVE_STRICT, &format!("Live test blocked: needs {} via ${entidEnvVar}", live_key));
+                return;
+            }
+        }
+    }
+`
+}
+
+
 // Replace raw OpenAPI parameter names in path parts with model parameter
 // names (twin of TestDirect_go's normalizePathParams).
 function normalizePathParams(
@@ -126,6 +142,10 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const entidEnvVar = `${PROJECTNAME}_TEST_${envToken(entity.name)}_ENTID`
 
+  // The *_ENTID key a live test reads a parameter's value from.
+  const liveKey = (param: any): string =>
+    ('id' === param.n ? entity.name : param.n.replace(/_id$/, '')) + '01'
+
   const evar = rustVarName(entity.name)
 
   File({ name: entity.name + '_direct_test.' + target.ext }, () => {
@@ -144,7 +164,10 @@ use common::*;
 
 use ${rustcrate}::core::helpers::{getp, ja, jo, json_thunk, setp, to_int, to_map};
 use ${rustcrate}::utility::voxgigstruct as vs;
-use ${rustcrate}::{Value, ${model.const.Name}SDK};
+use ${rustcrate}::{json_parse, Value, ${model.const.Name}SDK};
+
+${liveStrictNote(liveStrict(model, target.name), '//')}
+const LIVE_STRICT: bool = ${liveStrict(model, target.name)};
 
 struct ${entity.Name}DirectSetup {
     client: Rc<${model.const.Name}SDK>,
@@ -222,13 +245,7 @@ fn ${evar}_direct_setup(mockres: Value) -> ${entity.Name}DirectSetup {
 
     // ---- list test ----
     if (hasList && listPoint) {
-      // Live params: idmap keys per param.
-      const listLiveParams = listParams.map((p: any) => {
-        const key = p.n === 'id'
-          ? entity.name + '01'
-          : p.n.replace(/_id$/, '') + '01'
-        return { name: p.n, key }
-      })
+      const listLiveParams = listParams.map((p: any) => ({ name: p.n, key: liveKey(p) }))
 
       Content(`
 #[test]
@@ -250,53 +267,40 @@ fn ${evar}_direct_list() {
         );
         return;
     }
-`)
-
-      if (listLiveParams.length > 0) {
-        Content(`    if setup.live {
-        for live_key in [${listLiveParams.map((lp: any) => `"${lp.key}"`).join(', ')}] {
-            if getp(&setup.idmap, live_key).is_noval() {
-                eprintln!("skip: live test needs {} via *_ENTID env var (synthetic IDs only)", live_key);
-                return;
-            }
-        }
-    }
-`)
-      }
-
-      Content(`    let client = setup.client.clone();
+${liveKeysBlock(listLiveParams.map((lp: any) => lp.key), entidEnvVar)}    let client = setup.client.clone();
 
     let params = Value::empty_map();
 `)
       listLiveParams.forEach((lp: any, i: number) => {
-        const placeholder = 'direct0' + (i + 1)
         Content(`    if setup.live {
         setp(&params, "${lp.name}", getp(&setup.idmap, "${lp.key}"));
     } else {
-        setp(&params, "${lp.name}", Value::str("${placeholder}"));
+        setp(&params, "${lp.name}", Value::str("direct0${i + 1}"));
     }
 `)
       })
 
       Content(`
-    let result = client
-        .direct(jo(vec![
-            ("path", Value::str("${listPath}")),
-            ("method", Value::str("GET")),
-            ("params", params.clone()),
-        ]))
-        .expect("direct failed");
+    let result = match client.direct(jo(vec![
+        ("path", Value::str("${listPath}")),
+        ("method", Value::str("GET")),
+        ("params", params.clone()),
+    ])) {
+        Ok(result) => result,
+        Err(err) if setup.live => {
+            live_miss(LIVE_STRICT, &format!("Live list failed: {}", err));
+            return;
+        }
+        Err(err) => panic!("direct failed: {}", err),
+    };
 
     if setup.live {
-        // Live mode is lenient: synthetic IDs frequently 4xx and the
-        // list-response shape varies wildly across public APIs.
-        if getp(&result, "ok") != Value::Bool(true) {
-            eprintln!("skip: list call not ok (likely synthetic IDs against live API)");
+        if !live_ok(&result) {
+            live_miss(LIVE_STRICT, &format!("Live list failed: {}", live_describe(&result)));
             return;
         }
-        let status = to_int(&getp(&result, "status"));
-        if !(200..300).contains(&status) {
-            eprintln!("skip: expected 2xx status, got {}", status);
+        if live_list(&getp(&result, "data")).is_none() {
+            live_miss(LIVE_STRICT, &format!("Live list returned no list: {}", live_describe(&result)));
             return;
         }
     } else {
@@ -343,13 +347,13 @@ fn ${evar}_direct_list() {
 
     // ---- load test ----
     if (hasLoad && loadPoint) {
-      // idmap keys consumed by load in live mode.
-      const loadLiveParams = loadParams.map((p: any) => {
-        const key = p.n === 'id'
-          ? entity.name + '01'
-          : p.n.replace(/_id$/, '') + '01'
-        return { name: p.n, key }
-      })
+      const examples = 0 < loadParams.length &&
+        loadParams.every((p: any) => undefined !== p.ex && null !== p.ex)
+      const discover = !examples && hasList && 0 < loadParams.length
+      const idParam = loadParams.find((p: any) => 'id' === p.n)?.n ?? loadParams[0]?.n ?? 'id'
+      const loadLiveIdKeys: string[] = examples ? [] :
+        discover ? listParams.map(liveKey).concat(loadParams.filter((p: any) => idParam !== p.n).map(liveKey)) :
+          loadParams.map(liveKey)
 
       Content(`
 #[test]
@@ -368,53 +372,94 @@ fn ${evar}_direct_load() {
         );
         return;
     }
-`)
+${liveKeysBlock([...new Set(loadLiveIdKeys)], entidEnvVar)}    let client = setup.client.clone();
 
-      if (loadLiveParams.length > 0) {
-        Content(`    if setup.live {
-        for live_key in [${loadLiveParams.map((lp: any) => `"${lp.key}"`).join(', ')}] {
-            if getp(&setup.idmap, live_key).is_noval() {
-                eprintln!("skip: live test needs {} via *_ENTID env var (synthetic IDs only)", live_key);
+    let params = Value::empty_map();
+    if setup.live {
+`)
+      if (examples) {
+        for (const p of loadParams) {
+          Content(`        setp(&params, "${p.n}", json_parse(r##"${JSON.stringify(p.ex)}"##).unwrap_or(Value::Noval));
+`)
+        }
+      }
+      else if (discover) {
+        Content(`        let list_result = match client.direct(jo(vec![
+            ("path", Value::str("${listPath}")),
+            ("method", Value::str("GET")),
+            ("params", jo(vec![${listParams.map((p: any) => `("${p.n}", getp(&setup.idmap, "${liveKey(p)}"))`).join(', ')}])),
+        ])) {
+            Ok(list_result) => list_result,
+            Err(err) => {
+                live_miss(LIVE_STRICT, &format!("Live list discovery failed: {}", err));
                 return;
             }
+        };
+        if !live_ok(&list_result) {
+            live_miss(LIVE_STRICT, &format!("Live list discovery failed: {}", live_describe(&list_result)));
+            return;
         }
-    }
+        let records = match live_list(&getp(&list_result, "data")) {
+            Some(records) => records,
+            None => {
+                live_miss(LIVE_STRICT, &format!("Live list discovery returned no list: {}", live_describe(&list_result)));
+                return;
+            }
+        };
+        let first = vs::get_elem(&records, &Value::Num(0.0), Value::Noval);
+        if first.is_noval() {
+            live_empty("The account has no ${entity.name} record to load");
+            return;
+        }
+        let mut found = getp(&first, "${idParam}");
+        if found.is_noval() {
+            found = getp(&first, "id");
+        }
+        if found.is_noval() {
+            live_miss(LIVE_STRICT, "Live load blocked: discovery returned no usable identity");
+            return;
+        }
+        setp(&params, "${idParam}", found);
 `)
+        for (const p of loadParams.filter((p: any) => idParam !== p.n)) {
+          Content(`        setp(&params, "${p.n}", getp(&setup.idmap, "${liveKey(p)}"));
+`)
+        }
       }
-
-      Content(`    let client = setup.client.clone();
-
-    let params = Value::empty_map();
+      else {
+        for (const p of loadParams) {
+          Content(`        setp(&params, "${p.n}", getp(&setup.idmap, "${liveKey(p)}"));
 `)
-
-      loadLiveParams.forEach((lp: any, i: number) => {
-        const placeholder = 'direct0' + (i + 1)
-        Content(`    if setup.live {
-        setp(&params, "${lp.name}", getp(&setup.idmap, "${lp.key}"));
-    } else {
-        setp(&params, "${lp.name}", Value::str("${placeholder}"));
-    }
+        }
+      }
+      Content(`    } else {
+`)
+      loadParams.forEach((p: any, i: number) => {
+        Content(`        setp(&params, "${p.n}", Value::str("direct0${i + 1}"));
 `)
       })
+      Content(`    }
 
-      Content(`
-    let result = client
-        .direct(jo(vec![
-            ("path", Value::str("${loadPath}")),
-            ("method", Value::str("GET")),
-            ("params", params.clone()),
-        ]))
-        .expect("direct failed");
+    let result = match client.direct(jo(vec![
+        ("path", Value::str("${loadPath}")),
+        ("method", Value::str("GET")),
+        ("params", params.clone()),
+    ])) {
+        Ok(result) => result,
+        Err(err) if setup.live => {
+            live_miss(LIVE_STRICT, &format!("Live load failed: {}", err));
+            return;
+        }
+        Err(err) => panic!("direct failed: {}", err),
+    };
 
     if setup.live {
-        // Live mode is lenient: synthetic IDs frequently 4xx.
-        if getp(&result, "ok") != Value::Bool(true) {
-            eprintln!("skip: load call not ok (likely synthetic IDs against live API)");
+        if !live_ok(&result) {
+            live_miss(LIVE_STRICT, &format!("Live load failed: {}", live_describe(&result)));
             return;
         }
-        let status = to_int(&getp(&result, "status"));
-        if !(200..300).contains(&status) {
-            eprintln!("skip: expected 2xx status, got {}", status);
+        if getp(&result, "data").is_noval() {
+            live_miss(LIVE_STRICT, &format!("Live load returned no data: {}", live_describe(&result)));
             return;
         }
     } else {