@voxgig/sdkgen 4.5.3 → 4.6.0

package/project/.sdk/tm/js/test/feature/Corpus.test.js

@@ -84,7 +84,16 @@ function scriptedFetcher(res) {
 
 
 function makeClient(kase) {
+  // `test: { active: true }` is the OPTION, not the `test` FEATURE.
+  //
+  // It says "this client is not live", which is what makes a REQUIRED
+  // OpenAPI server variable resolve to a deterministic `test-<name>`
+  // rather than refuse to construct (see makeOptions). It installs no
+  // transport, so the scripted fetcher below still stands — the FEATURE
+  // is transport: 'base' and would shadow it, which is why this cannot
+  // just turn the feature on.
   return new SDK({
+    test: { active: true },
     feature: kase.feature,
     utility: { fetcher: scriptedFetcher(kase.res || [{ status: 200, body: {} }]) },
   })

package/project/.sdk/tm/kotlin/utility/MakeOptions.kt

@@ -28,8 +28,24 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
     }
   }
 
+  // `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 null
+  // check on the value, which cannot distinguish them.
+  val authSuppressed = options.containsKey("auth") && null == options["auth"]
+
   var opts = Struct.clone(options) as MutableMap<String, Any?>
 
+  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 list to a
@@ -107,6 +123,11 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
   val validated = Struct.validate(merged, optspec, vopts)
   opts = validated as MutableMap<String, Any?>
 
+  // Restore the suppression the optspec default would otherwise erase.
+  if (authSuppressed) {
+    opts["auth"] = null
+  }
+
   // Restore system.fetch.
   if (sysFetch != null) {
     val sys = Helpers.toMapAny(opts["system"])

package/project/.sdk/tm/lean/src/SdkUtility.lean

@@ -260,8 +260,19 @@ def prepareAuth (ctx : Value) : SIO (Value × Option Value) := do
   | .map _ => do
     let headers ← gpMap specV "headers"
     let options ← gp ctx "options"
+    -- `auth: null` is the documented way to suppress auth outright: NO
+    -- authorization header, whatever the apikey says. Without this the
+    -- withheld credential goes on the wire.
+    --
+    -- The ports that run options through validate against an optspec carrying
+    -- an `auth` default can use absence as the signal (validate guarantees the
+    -- key is present otherwise). lean's makeOptions has no optspec, so `auth`
+    -- is ABSENT in the ordinary case and absence must stay the ordinary case.
+    -- getpropRaw is the only reader that tells a STORED null from an absent
+    -- key - gp collapses both to .noval - so the stored null alone suppresses.
+    let authRaw ← getpropRaw options "auth"
     let apikey ← gpS options "apikey"
-    if apikey == "" then do
+    if authRaw == .null || apikey == "" then do
       dp headers "authorization"
       pure (specV, none)
     else do

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -968,7 +968,16 @@ let make_options_util (ctx : ctx) : value =
       | Some u -> List.iter (fun k -> setp u.u_custom k (getp custom_utils k)) (keysof custom_utils)
       | None -> ())
    | _ -> ());
+  (* `auth: null` is the documented way to suppress auth outright. validate()
+     treats a STORED null as "no value" (getprop returns the alt), so the
+     optspec `auth` default would fire and turn the suppression into "use the
+     default auth" - transmitting a credential the caller withheld. getprop_raw
+     is the only reader that tells a stored Null from an absent key. Withhold
+     the key across merge/validate, then restore the null below. *)
+  let auth_suppressed =
+    (match getprop_raw options "auth" with Null -> true | _ -> false) in
   let opts = match clone options with Map _ as m -> m | _ -> empty_map () in
+  let () = if auth_suppressed then ignore (delprop opts (Str "auth")) in
   (* Feature add-order. options.feature may be given as an ordered LIST of
      {name; active; ...opts} entries (list position = add order) or a
      {name => {opts}} map. Normalize a list to a map (so merge/validate/init
@@ -999,6 +1008,8 @@ let make_options_util (ctx : ctx) : value =
   let merged = merge (ja [empty_map (); cfgopts; opts]) in
   let validated = validate merged optspec in
   let opts = match validated with Map _ as m -> m | _ -> empty_map () in
+  (* Restore the suppression the optspec default would otherwise erase. *)
+  let () = if auth_suppressed then setp opts "auth" Null in
   (* 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

package/project/.sdk/tm/perl/utility/make_options.pm

@@ -69,7 +69,22 @@ $REGISTRY{make_options} = sub {
   # reads options.extend, but clone/validate dropped the instances.
   my $extend_raw = ProjectNameHelpers::gp($options, 'extend');
 
+  # `auth => undef` is the documented way to disable auth outright, and
+  # prepare_auth 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 undef back.
+  # Same fix as ts/js/go make_options.
+  #
+  # Suppliedness cannot be recovered after validate, hence here, and it must
+  # tell an ABSENT auth from a present undef: exists rather than defined,
+  # which is false for both.
+  my $authsuppressed =
+    (ref($options) eq 'HASH' && exists $options->{auth} && !defined $options->{auth}) ? 1 : 0;
+
   my $opts = Voxgig::Struct::clone($options);
+
+  delete $opts->{auth} if $authsuppressed && ref($opts) eq 'HASH';
   $opts = {} unless Voxgig::Struct::ismap($opts);
   delete $opts->{extend};
 
@@ -143,6 +158,9 @@ $REGISTRY{make_options} = sub {
   my $validated = Voxgig::Struct::validate($merged, $optspec);
   $opts = Voxgig::Struct::ismap($validated) ? $validated : {};
 
+  # Restore the suppression the optspec default would otherwise erase.
+  $opts->{auth} = undef if $authsuppressed;
+
   if ($sys_fetch) {
     $opts->{system} = {} unless Voxgig::Struct::ismap($opts->{system});
     $opts->{system}{fetch} = $sys_fetch;

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

@@ -91,7 +91,16 @@ class FeatureCorpusTest extends TestCase
      */
     private static function buildClient(array $kase)
     {
-        $opts = ['utility' => ['fetcher' => self::scriptedFetcher($kase['res'] ?? null)]];
+        // 'test' here is the OPTION, not the `test` FEATURE. It says "this
+        // client is not live", which is what makes a REQUIRED OpenAPI server
+        // variable resolve to a deterministic test-<name> rather than throw
+        // at construction (see makeOptions). It installs no transport, so the
+        // scripted fetcher still stands - the FEATURE is transport: 'base'
+        // and would shadow it.
+        $opts = [
+            'test' => ['active' => true],
+            'utility' => ['fetcher' => self::scriptedFetcher($kase['res'] ?? null)],
+        ];
         if (isset($kase['feature'])) {
             $opts['feature'] = $kase['feature'];
         }

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

@@ -94,12 +94,31 @@ class ProjectNameMakeOptions
             }
         }
 
+        // `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: array_key_exists
+        // rather than isset, which is false for both.
+        $authsuppressed = is_array($options)
+            && array_key_exists('auth', $options)
+            && null === $options['auth'];
+
         $opts = \Voxgig\Struct\Struct::clone($options);
         $opts = self::to_array_deep($opts);
         if (!is_array($opts)) {
             $opts = [];
         }
 
+        if ($authsuppressed) {
+            unset($opts['auth']);
+        }
+
         // Feature add-order. options['feature'] may be given as an ordered LIST
         // of ['name'=>..., 'active'=>..., ...] entries (the list position IS the
         // order in which features are added), or as a ['name'=>[opts]] map.
@@ -164,6 +183,11 @@ class ProjectNameMakeOptions
             $opts = [];
         }
 
+        // Restore the suppression the optspec default would otherwise erase.
+        if ($authsuppressed) {
+            $opts['auth'] = null;
+        }
+
         // Reattach the station binding handle held aside above (the feature
         // optspec is `$OPEN`, so the extra keys are legal; they were only
         // kept out of the clone/validate round-trip).

package/project/.sdk/tm/py/pkg/utility/make_options.py

@@ -65,10 +65,26 @@ def make_options_util(ctx):
     if isinstance(options, dict) and options.get("extend") is not None:
         options = {k: v for k, v in options.items() if k != "extend"}
 
+    # `auth: None` is the documented way to disable auth outright, and
+    # prepare_auth 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 make_options.
+    #
+    # Suppliedness cannot be recovered after validate, hence here, and it
+    # must tell an ABSENT auth from a present None: only the latter is a
+    # suppression.
+    authsuppressed = (
+        isinstance(options, dict) and "auth" in options and options["auth"] is None)
+
     opts = vs.clone(options)
     if not isinstance(opts, dict):
         opts = {}
 
+    if authsuppressed:
+        opts.pop("auth", None)
+
     # 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 list to a
@@ -162,6 +178,10 @@ def make_options_util(ctx):
         validated = {}
     opts = validated
 
+    # Restore the suppression the optspec default would otherwise erase.
+    if authsuppressed:
+        opts["auth"] = None
+
     # 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

package/project/.sdk/tm/py/test/runner.py

@@ -101,6 +101,34 @@ class ProjectNameTestRunner:
                     return True, item.get("reason")
         return False, None
 
+    @staticmethod
+    def live_client_options():
+        """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.
+
+        Reserved fields are stripped HERE rather than at each merge site:
+        the generated dict 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.
+        """
+        ctrl = ProjectNameTestRunner.load_test_control()
+        opts = ctrl.get("test", {}).get("client", {}).get("options")
+        if not isinstance(opts, dict):
+            return {}
+        reserved = ("base", "prefix", "suffix", "server", "apikey", "secret")
+        return {k: v for k, v in opts.items() if k not in reserved}
+
     @staticmethod
     def live_delay_ms():
         """Per-test live pacing delay (ms); default 500."""
@@ -161,5 +189,9 @@ def load_test_control():
     return ProjectNameTestRunner.load_test_control()
 
 
+def live_client_options():
+    return ProjectNameTestRunner.live_client_options()
+
+
 def live_delay_ms():
     return ProjectNameTestRunner.live_delay_ms()

package/project/.sdk/tm/py/test/test_feature_corpus.py

@@ -95,7 +95,16 @@ def _client(kase):
     transport: 'base' and REPLACES the transport, so a client in test mode
     would shadow the script.
     """
-    opts = {"utility": {"fetcher": _scripted_fetcher(kase.get("res"))}}
+    # "test" here is the OPTION, not the `test` FEATURE. It says "this
+    # client is not live", which is what makes a REQUIRED OpenAPI server
+    # variable resolve to a deterministic test-<name> rather than raise at
+    # construction (see make_options). It installs no transport, so the
+    # scripted fetcher still stands - the FEATURE is transport: 'base' and
+    # would shadow it, which is why this cannot just turn the feature on.
+    opts = {
+        "test": {"active": True},
+        "utility": {"fetcher": _scripted_fetcher(kase.get("res"))},
+    }
     if kase.get("feature") is not None:
         opts["feature"] = kase["feature"]
     return ProjectNameSDK(opts)

package/project/.sdk/tm/rb/test/feature_corpus_test.rb

@@ -71,7 +71,15 @@ class FeatureCorpusTest < Minitest::Test
   # transport: 'base' and REPLACES the transport, so a client in test mode
   # would shadow the script.
   def build_client(kase)
-    opts = { "utility" => { "fetcher" => scripted_fetcher(kase["res"]) } }
+    # "test" here is the OPTION, not the `test` FEATURE. It says "this
+    # client is not live", which is what makes a REQUIRED OpenAPI server
+    # variable resolve to a deterministic test-<name> rather than raise at
+    # construction (see make_options). It installs no transport, so the
+    # scripted fetcher still stands.
+    opts = {
+      "test" => { "active" => true },
+      "utility" => { "fetcher" => scripted_fetcher(kase["res"]) },
+    }
     opts["feature"] = kase["feature"] unless kase["feature"].nil?
     ProjectNameSDK.new(opts)
   end

package/project/.sdk/tm/rb/utility/make_options.rb

@@ -40,9 +40,23 @@ module ProjectNameUtilities
       end
     end
 
+    # `auth: nil` is the documented way to disable auth outright, and
+    # prepare_auth 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 nil back. Same fix as ts/js/go make_options.
+    #
+    # Suppliedness cannot be recovered after validate, hence here, and it
+    # must tell an ABSENT auth from a present nil: only the latter is a
+    # suppression.
+    authsuppressed = options.is_a?(Hash) && options.key?('auth') && options['auth'].nil?
+
     opts = VoxgigStruct.clone(options)
     opts = {} unless opts.is_a?(Hash)
 
+    opts.delete('auth') if authsuppressed
+
     # Feature add-order. options["feature"] may be given as an ordered ARRAY of
     # { "name" => ..., "active" => ..., ... } entries (the array position IS the
     # order in which features are added), or as a { "name" => {opts} } map.
@@ -109,6 +123,9 @@ module ProjectNameUtilities
     validated = VoxgigStruct.validate(merged, optspec)
     opts = validated.is_a?(Hash) ? validated : {}
 
+    # Restore the suppression the optspec default would otherwise erase.
+    opts['auth'] = nil if authsuppressed
+
     # 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

package/project/.sdk/tm/rust/utility/make_options.rs

@@ -23,8 +23,28 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
+    // `auth: null` is the documented way to disable auth outright, and
+    // prepare_auth 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 make_options.
+    //
+    // Read the map DIRECTLY rather than through get_prop: get_prop applies
+    // the Group A rule and returns the alt for a stored null, so it cannot
+    // tell an absent auth from a suppressed one - and only the latter is a
+    // suppression.
+    let auth_suppressed = match &options {
+        Value::Map(m) => matches!(m.borrow().get("auth"), Some(Value::Null)),
+        _ => false,
+    };
+
     let mut opts = vs::clone(&options);
 
+    if auth_suppressed {
+        opts = vs::del_prop(opts, &Value::str("auth"));
+    }
+
     // Feature add-order. `options.feature` may be an ordered List of
     // { name, active, ...opts } entries (the List position IS the order in
     // which features are added), or a { name: {opts} } map. Normalize a List
@@ -120,6 +140,11 @@ pub fn make_options_util(ctx: &Rc<Context>) -> Value {
         }
     }
 
+    // Restore the suppression the optspec default would otherwise erase.
+    if auth_suppressed {
+        setp(&opts, "auth", Value::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 resolves to "" is a

package/project/.sdk/tm/scala/utility/Make.scala

@@ -254,8 +254,22 @@ object MakeOptions {
       }
     }
 
+    // `auth: null` is the documented way to suppress auth outright, and
+    // prepareAuth honours it before it ever reads the apikey. It cannot survive
+    // validate: a stored null reads as "no value", so the optspec `auth`
+    // default fires and the suppression becomes "use the default auth" -
+    // transmitting the credential the caller withheld. Withhold the key for
+    // validate, then put the null back. Same fix as ts/js/go/java 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.
+    val authSuppressed = options.containsKey("auth") && null == options.get("auth")
+
     var opts = Struct.clone(options).asInstanceOf[JMap[String, Object]]
 
+    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
@@ -330,6 +344,9 @@ object MakeOptions {
     val validated = Struct.validate(merged, optspec, vopts)
     opts = validated.asInstanceOf[JMap[String, Object]]
 
+    // Restore the suppression the optspec default would otherwise erase.
+    if (authSuppressed) opts.put("auth", null)
+
     // Restore system.fetch.
     if (sysFetch != null) {
       val sys = Helpers.toMapAny(opts.get("system"))

package/project/.sdk/tm/swift/Sources/ProjectNameSDK/utility/MakeOptions.swift

@@ -85,8 +85,24 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
     }
   }
 
+  // `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.
+  //
+  // `isNull` rather than `isNil`: the latter is also true for Noval, so it
+  // cannot tell an ABSENT auth from a suppressed one, and only the latter is
+  // a suppression.
+  let authSuppressed = options.entries["auth"]?.isNull ?? false
+
   let opts = clone(.map(options)).asMap ?? VMap()
 
+  if authSuppressed {
+    opts.entries.removeValue(forKey: "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 list to a
@@ -124,6 +140,11 @@ func makeOptionsUtil(_ ctx: Context) -> VMap {
   let validated = validate(merged, optspec)
   let result = validated.asMap ?? VMap()
 
+  // Restore the suppression the optspec default would otherwise erase.
+  if authSuppressed {
+    result.entries["auth"] = .null
+  }
+
   // Restore system.fetch.
   if !isNil(sysFetch) {
     if let sm = gp(result, "system").asMap {