@voxgig/sdkgen 4.5.3 → 4.6.0

package/project/.sdk/tm/go/utility/transform_request.go

@@ -24,9 +24,37 @@ func transformRequestUtil(ctx *core.Context) any {
 		return ctx.Reqdata
 	}
 
-	reqdata := vs.Transform(map[string]any{
+	// Transform gained an error return in struct go 0.1.3. The TS reference
+	// wraps this call in try/catch and returns makeError(ctx, err) — but ts's
+	// makeError THROWS unless ctrl.throw is false, so that `return` is only
+	// ever reached on the non-throwing path. go's makeError cannot throw; it
+	// returns the error instead. Handing that back as the `any` this seam
+	// returns would make it the request BODY, so makeSpec re-raises it (see
+	// the abort there). On the ctrl.throw-false path makeError yields
+	// result.Resdata and this returns a real value, as ts does.
+	reqdata, terr := vs.Transform(map[string]any{
 		"reqdata": ctx.Reqdata,
 	}, reqform)
 
+	if terr != nil {
+		// Only the NON-throwing path goes through makeError here. With
+		// ctrl.throw false, ts's makeError returns result.resdata and the
+		// pipeline continues with it as the body; mirror that.
+		//
+		// On the throwing path the error is handed back raw, for makeSpec to
+		// re-raise and the operation to process once. Calling makeError here
+		// as well would report the same failure TWICE — it fires the
+		// PreUnexpected hook, and the operation fires it again when it
+		// handles what makeSpec re-raised. The built-in observability
+		// features happen to dedupe on a per-context marker, but a
+		// project-supplied feature may legitimately count or log on every
+		// dispatch, and ts dispatches once.
+		if ctx.Ctrl != nil && ctx.Ctrl.Throw != nil && !*ctx.Ctrl.Throw {
+			out, _ := makeErrorUtil(ctx, terr)
+			return out
+		}
+		return terr
+	}
+
 	return reqdata
 }

package/project/.sdk/tm/go/utility/transform_response.go

@@ -29,7 +29,12 @@ func transformResponseUtil(ctx *core.Context) any {
 		return nil
 	}
 
-	resdata := vs.Transform(map[string]any{
+	// Transform gained an error return in struct go 0.1.3. Both callers
+	// (makeResponse, makeResult) DISCARD this function's return value, so an
+	// error handed back that way would vanish. The convention they do honour
+	// is result.Err — makeResponse sets result.Ok only when it is nil, and
+	// GraphqlErrors reports the same way — so report there.
+	resdata, terr := vs.Transform(map[string]any{
 		"ok":         result.Ok,
 		"status":     result.Status,
 		"statusText": result.StatusText,
@@ -40,6 +45,20 @@ func transformResponseUtil(ctx *core.Context) any {
 		"resmatch":   result.Resmatch,
 	}, resform)
 
+	if terr != nil {
+		// Ok must be cleared as well as Err. This runs from BOTH makeResponse
+		// and makeResult, and only the makeResult call actually reaches the
+		// transform: resultBasic never sets Ok, so the makeResponse call
+		// returns at the !result.Ok guard above, and makeResponse then sets
+		// Ok true. By the time the transform really runs, Ok is already true —
+		// and doneUtil returns result.Resdata whenever Ok is true, without
+		// ever consulting Err. Recording only the error would leave a failed
+		// response transform resolving successfully.
+		result.Err = ctx.MakeError("resform", "resform: "+terr.Error())
+		result.Ok = false
+		return nil
+	}
+
 	result.Resdata = resdata
 	return resdata
 }

package/project/.sdk/tm/java/test/CustomUtilityTest.java

@@ -86,7 +86,12 @@ public class CustomUtilityTest {
     // transport: 'base' - it REPLACES the transport by design - so a client in
     // test mode would shadow the scripted fetcher and this would assert
     // nothing.
+    // "test" is the OPTION, not the `test` FEATURE: it says "this client is
+    // not live", so a REQUIRED OpenAPI server variable resolves to a
+    // deterministic test-<name> instead of failing construction. It installs
+    // no transport, so the scripted fetcher still stands.
     ProjectNameSDK client = new ProjectNameSDK(fhMap(
+        "test", fhMap("active", true),
         "utility", fhMap("fetcher", scripted)));
 
     Utility u = client.getUtility();
@@ -106,7 +111,12 @@ public class CustomUtilityTest {
   // halves cannot be satisfied by a switch that also swallows extras.
   @Test
   public void anUnknownKeyIsStillAttached() {
+    // "test" is the OPTION, not the `test` FEATURE: it says "this client is
+    // not live", so a REQUIRED OpenAPI server variable resolves to a
+    // deterministic test-<name> instead of failing construction. It installs
+    // no transport, so the scripted fetcher still stands.
     ProjectNameSDK client = new ProjectNameSDK(fhMap(
+        "test", fhMap("active", true),
         "utility", fhMap("notAUtilityMember", (Supplier<String>) () -> "EXTRA")));
     assertTrue(client.getUtility().custom.containsKey("notAUtilityMember"),
         "an unknown utility key was dropped instead of kept in custom");

package/project/.sdk/tm/java/test/FeatureCorpusTest.java

@@ -128,7 +128,14 @@ public class FeatureCorpusTest {
     Map<String, Object> utility = new LinkedHashMap<>();
     utility.put("fetcher", scriptedFetcher(kase.get("res")));
 
+    // "test" is the OPTION, not the `test` FEATURE: it says "this client is
+    // not live", so a REQUIRED OpenAPI server variable resolves to a
+    // deterministic test-<name> instead of failing construction. It installs
+    // no transport, so the scripted fetcher still stands.
     Map<String, Object> opts = new LinkedHashMap<>();
+    Map<String, Object> testopt = new LinkedHashMap<>();
+    testopt.put("active", true);
+    opts.put("test", testopt);
     opts.put("utility", utility);
     if (kase.get("feature") != null) {
       opts.put("feature", kase.get("feature"));

package/project/.sdk/tm/java/test/PrimaryUtilityTest.java

@@ -271,7 +271,10 @@ public class PrimaryUtilityTest {
   @Test
   public void fetcherLive() {
     final List<Map<String, Object>> calls = new ArrayList<>();
+    // Concrete base: a live construction must satisfy any server variables a
+    // templated base URL declares; a literal base sidesteps the requirement.
     ProjectNameSDK liveClient = new ProjectNameSDK(fhMap(
+        "base", "http://localhost:8080",
         "system", fhMap(
             "fetch", (BiFunction<String, Map<String, Object>, Map<String, Object>>)
                 (url, fetchdef) -> {
@@ -296,7 +299,10 @@ public class PrimaryUtilityTest {
   public void fetcherBlockedTestMode() {
     // Create a live SDK then set mode to test (not using testSDK, which
     // installs the test feature).
+    // Concrete base: a live construction must satisfy any server variables a
+    // templated base URL declares; a literal base sidesteps the requirement.
     ProjectNameSDK blockedClient = new ProjectNameSDK(fhMap(
+        "base", "http://localhost:8080",
         "system", fhMap(
             "fetch", (BiFunction<String, Map<String, Object>, Map<String, Object>>)
                 (url, fetchdef) -> new LinkedHashMap<>())));

package/project/.sdk/tm/java/test/RunnerSupport.java

@@ -172,6 +172,49 @@ public final class RunnerSupport {
     return null;
   }
 
+  // liveClientOptions returns the extra SDK options every LIVE client is
+  // constructed with, from sdk-test-control.json `test.client.options`.
+  //
+  // The generated live client knows two things: the base URL (from the
+  // spec) and the credential (from the environment). Everything else about
+  // how a particular API wants to be talked to - which features to switch
+  // on, and with what settings - is a property of THAT API, known to the
+  // project and to nothing in the toolchain.
+  //
+  // Merged UNDER the generated fields, so the suite's own base/apikey/server
+  // values win: this ADDS to the live client, it does not redirect it.
+  //
+  // That contract is enforced HERE rather than left to each merge site: the
+  // generated map only names a field when the model calls for one, so a
+  // "base" in this block would face no competing value and would silently
+  // redirect the whole suite - credential included - to another host.
+  private static final List<String> LIVE_RESERVED = List.of(
+      "base", "prefix", "suffix", "server", "apikey", "secret");
+
+  public static Map<String, Object> liveClientOptions() {
+    Map<String, Object> ctrl = loadTestControl();
+    Map<String, Object> test = Helpers.toMapAny(ctrl.get("test"));
+    if (test == null) {
+      return new LinkedHashMap<>();
+    }
+    Map<String, Object> client = Helpers.toMapAny(test.get("client"));
+    if (client == null) {
+      return new LinkedHashMap<>();
+    }
+    Map<String, Object> opts = Helpers.toMapAny(client.get("options"));
+    if (opts == null) {
+      return new LinkedHashMap<>();
+    }
+
+    Map<String, Object> out = new LinkedHashMap<>();
+    for (Map.Entry<String, Object> e : opts.entrySet()) {
+      if (!LIVE_RESERVED.contains(e.getKey())) {
+        out.put(e.getKey(), e.getValue());
+      }
+    }
+    return out;
+  }
+
   // liveDelayMs returns the configured per-test live delay in ms; default 500.
   public static int liveDelayMs() {
     Map<String, Object> ctrl = loadTestControl();

package/project/.sdk/tm/java/utility/MakeOptions.java

@@ -4,6 +4,8 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.Helpers;
@@ -12,6 +14,9 @@ import JAVAPACKAGE.utility.struct.Struct;
 @SuppressWarnings({"unchecked"})
 final class MakeOptions {
 
+  // {name} placeholders in a templated server URL (OpenAPI server variables).
+  private static final Pattern SERVER_VAR = Pattern.compile("\\{([A-Za-z0-9_]+)\\}");
+
   private MakeOptions() {}
 
   static Map<String, Object> makeOptions(Context ctx) {
@@ -36,8 +41,24 @@ final class MakeOptions {
       }
     }
 
+    // `auth: null` is the documented way to disable auth outright, and
+    // PrepareAuth honours it before it ever reads the apikey. It cannot
+    // survive validate: depending on the struct port a stored null is either
+    // REPLACED by the optspec default - transmitting the credential the
+    // caller withheld - or REJECTED outright. Withhold the key for validate,
+    // then put the null back. Same fix as ts/js/go makeOptions.
+    //
+    // Suppliedness cannot be recovered after validate, hence here, and it
+    // must tell an ABSENT auth from a present null: containsKey rather than
+    // a get() null check, which cannot distinguish them.
+    boolean authSuppressed = options.containsKey("auth") && null == options.get("auth");
+
     Map<String, Object> opts = (Map<String, Object>) Struct.clone(options);
 
+    if (authSuppressed) {
+      opts.remove("auth");
+    }
+
     // Feature add-order. options.feature may be given as an ordered LIST of
     // { name, active, ...opts } entries (the list position IS the order in
     // which features are added), or as a { name: {opts} } map. Normalize a
@@ -91,7 +112,12 @@ final class MakeOptions {
         + "\"utility\": {},"
         + "\"system\": {},"
         + "\"test\": { \"active\": false, \"entity\": { \"`$OPEN`\": true } },"
-        + "\"clean\": { \"keys\": \"key,token,id\" }"
+        + "\"clean\": { \"keys\": \"key,token,id\" },"
+        // Server-variable values for a templated base URL (OpenAPI server
+        // variables): {name} placeholders in `base` are substituted from
+        // this map at construction. Spec defaults arrive via the generated
+        // Config; user values override them.
+        + "\"server\": { \"`$CHILD`\": \"\" }"
         + "}");
 
     // Preserve system.fetch before merge/validate.
@@ -115,6 +141,11 @@ final class MakeOptions {
     Object validated = Struct.validate(merged, optspec, vopts);
     opts = (Map<String, Object>) validated;
 
+    // Restore the suppression the optspec default would otherwise erase.
+    if (authSuppressed) {
+      opts.put("auth", null);
+    }
+
     // Restore system.fetch.
     if (sysFetch != null) {
       Map<String, Object> sys = Helpers.toMapAny(opts.get("system"));
@@ -128,6 +159,58 @@ final class MakeOptions {
       }
     }
 
+    // Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
+    //
+    // Every placeholder must resolve to a non-empty value: from
+    // options["server"] (user), else the Config default. A placeholder that
+    // resolves to "" is a construction ERROR in live mode - the URL cannot
+    // work - but in test mode substitutes the deterministic value
+    // `test-<name>` so offline tests need no configuration.
+    Object baseObj = opts.get("base");
+    if (baseObj instanceof String && ((String) baseObj).indexOf('{') >= 0) {
+      String base = (String) baseObj;
+
+      boolean testmode =
+          Boolean.TRUE.equals(Struct.getpath(opts, List.of("test", "active")))
+          || Boolean.TRUE.equals(
+              Struct.getpath(opts, List.of("feature", "test", "active")));
+
+      Map<String, Object> server = Helpers.toMapAny(opts.get("server"));
+
+      Matcher m = SERVER_VAR.matcher(base);
+      StringBuilder resolved = new StringBuilder();
+      int at = 0;
+      while (m.find()) {
+        String name = m.group(1);
+        Object raw = server == null ? null : server.get(name);
+        String val = raw instanceof String ? (String) raw : "";
+
+        if ("".equals(val)) {
+          if (testmode) {
+            val = "test-" + name;
+          }
+          else {
+            String sdkname = "SDK";
+            Object mainName = Struct.getpath(config, List.of("main", "name"));
+            if (mainName instanceof String) {
+              sdkname = (String) mainName;
+            }
+            throw new IllegalArgumentException(
+                sdkname + ": the server variable '" + name + "' is required: "
+                + "the API base URL is '" + base + "' - pass "
+                + "options.put(\"server\", Map.of(\"" + name + "\", \"...\")) "
+                + "in the SDK options");
+          }
+        }
+
+        resolved.append(base, at, m.start()).append(val);
+        at = m.end();
+      }
+      resolved.append(base.substring(at));
+
+      opts.put("base", resolved.toString());
+    }
+
     // Derived clean config.
     String cleanKeys = "key,token,id";
     Object ck = Struct.getpath(opts, List.of("clean", "keys"));

package/project/.sdk/tm/js/src/utility/MakeOptionsUtility.js

@@ -9,8 +9,27 @@ function makeOptions(ctx) {
   const validate = struct.validate
   const escre = struct.escre
 
+  // `auth: null` is the documented way to disable auth outright, and
+  // prepareAuth honours it before it ever reads the apikey. But it cannot
+  // survive validate: this target's struct rejects a stored null outright
+  // ("Expected field auth to be map, but found no value"), so passing it
+  // through turns the documented suppression into a CONSTRUCTION ERROR.
+  //
+  // Withhold the key for validate, then put the null back. Deleting rather
+  // than leaving it is what avoids the throw; restoring it afterwards is
+  // what stops the optspec's `auth` default from taking its place, which
+  // would transmit the credential the caller asked to withhold.
+  //
+  // Suppliedness cannot be recovered after validate, hence here. `null ===`
+  // rather than `null ==`, so an OMITTED auth is not read as a suppression.
+  const authsuppressed = null === (options || {}).auth
+
   let opts = { ...(options || {}) }
 
+  if (authsuppressed) {
+    delete opts.auth
+  }
+
   // Feature add-order. `options.feature` may be given as an ordered ARRAY of
   // { name, active, ...opts } entries (the array position IS the order in
   // which features are added), or as a { name: {opts} } map. Normalize an
@@ -108,6 +127,11 @@ function makeOptions(ctx) {
 
   opts = validate(opts, optspec)
 
+  // Restore the suppression the optspec default would otherwise erase.
+  if (authsuppressed) {
+    opts.auth = null
+  }
+
   // Resolve a templated base URL (e.g. https://{tenant_id}.hanko.io).
   // Every placeholder must resolve to a non-empty value: from
   // options.server (user), else the Config default. A placeholder that