@voxgig/sdkgen 4.2.7 → 4.3.0

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

@@ -39,3 +39,197 @@ func registerAll(u *core.Utility) {
 	u.TransformRequest = transformRequestUtil
 	u.TransformResponse = transformResponseUtil
 }
+
+// overrideUtil replaces one utility member from `options.utility`, matching
+// the ts reference: a key naming a real utility member REPLACES it, and any
+// other key is attached as a custom extra.
+//
+// Without this the override was a no-op here. `makeOptions` put every entry
+// in `u.Custom`, which nothing reads, so a caller passing
+// `utility: {"fetcher": myTransport}` - the documented way to script the
+// transport, and the seam the shared feature corpus runs on - was silently
+// ignored while ts and js honoured it. The custom-utility test did not catch
+// it because it asserted the side map rather than the behaviour.
+//
+// Returns false when the key names no member, or when the value is not that
+// member's signature; the caller then keeps it in Custom. A wrong signature
+// is deliberately NOT an error: ts attaches whatever it is given, so a typed
+// port that rejected it outright would diverge in the other direction.
+//
+// Keep this list in step with registerAll above - a utility added to one and
+// not the other is overridable in ts and not here, which is the divergence
+// this exists to remove.
+func overrideUtil(u *core.Utility, key string, val any) bool {
+	switch key {
+	case "clean":
+		if fn, ok := val.(func(ctx *core.Context, val any) any); ok {
+			u.Clean = fn
+			return true
+		}
+	case "done":
+		if fn, ok := val.(func(ctx *core.Context) (any, error)); ok {
+			u.Done = fn
+			return true
+		}
+	case "makeError":
+		if fn, ok := val.(func(ctx *core.Context, err error) (any, error)); ok {
+			u.MakeError = fn
+			return true
+		}
+	case "featureAdd":
+		if fn, ok := val.(func(ctx *core.Context, f core.Feature)); ok {
+			u.FeatureAdd = fn
+			return true
+		}
+	case "featureHook":
+		if fn, ok := val.(func(ctx *core.Context, name string)); ok {
+			u.FeatureHook = fn
+			return true
+		}
+	case "featureInit":
+		if fn, ok := val.(func(ctx *core.Context, f core.Feature)); ok {
+			u.FeatureInit = fn
+			return true
+		}
+	case "fetcher":
+		// BOTH SPELLINGS. Fetcher is the one member declared as a NAMED type,
+		// and a type assertion to a defined type matches only that exact
+		// dynamic type. A plain function literal in a map[string]any - the
+		// ordinary way to write this - carries the UNNAMED signature and
+		// asserts to `func(...)` but not to `core.FetcherFunc`; a value the
+		// caller converted asserts to `core.FetcherFunc` but not to the
+		// unnamed one. Accepting only the named type shelved every ordinary
+		// caller's transport in Custom, which is the exact defect this
+		// function exists to remove.
+		if fn, ok := val.(core.FetcherFunc); ok {
+			u.Fetcher = fn
+			return true
+		}
+		if fn, ok := val.(func(ctx *core.Context, fullurl string,
+			fetchdef map[string]any) (any, error)); ok {
+			u.Fetcher = fn
+			return true
+		}
+	case "makeFetchDef":
+		if fn, ok := val.(func(ctx *core.Context) (map[string]any, error)); ok {
+			u.MakeFetchDef = fn
+			return true
+		}
+	case "makeContext":
+		if fn, ok := val.(func(ctxmap map[string]any, basectx *core.Context) *core.Context); ok {
+			u.MakeContext = fn
+			return true
+		}
+	case "makeOptions":
+		if fn, ok := val.(func(ctx *core.Context) map[string]any); ok {
+			u.MakeOptions = fn
+			return true
+		}
+	case "makeRequest":
+		if fn, ok := val.(func(ctx *core.Context) (*core.Response, error)); ok {
+			u.MakeRequest = fn
+			return true
+		}
+	case "makeResponse":
+		if fn, ok := val.(func(ctx *core.Context) (*core.Response, error)); ok {
+			u.MakeResponse = fn
+			return true
+		}
+	case "makeResult":
+		if fn, ok := val.(func(ctx *core.Context) (*core.Result, error)); ok {
+			u.MakeResult = fn
+			return true
+		}
+	case "makePoint":
+		if fn, ok := val.(func(ctx *core.Context) (map[string]any, error)); ok {
+			u.MakePoint = fn
+			return true
+		}
+	case "makeSpec":
+		if fn, ok := val.(func(ctx *core.Context) (*core.Spec, error)); ok {
+			u.MakeSpec = fn
+			return true
+		}
+	case "makeUrl":
+		if fn, ok := val.(func(ctx *core.Context) (string, error)); ok {
+			u.MakeUrl = fn
+			return true
+		}
+	case "param":
+		if fn, ok := val.(func(ctx *core.Context, paramdef any) any); ok {
+			u.Param = fn
+			return true
+		}
+	case "prepareAuth":
+		if fn, ok := val.(func(ctx *core.Context) (*core.Spec, error)); ok {
+			u.PrepareAuth = fn
+			return true
+		}
+	case "prepareBody":
+		if fn, ok := val.(func(ctx *core.Context) any); ok {
+			u.PrepareBody = fn
+			return true
+		}
+	case "prepareHeaders":
+		if fn, ok := val.(func(ctx *core.Context) map[string]any); ok {
+			u.PrepareHeaders = fn
+			return true
+		}
+	case "prepareMethod":
+		if fn, ok := val.(func(ctx *core.Context) string); ok {
+			u.PrepareMethod = fn
+			return true
+		}
+	case "prepareParams":
+		if fn, ok := val.(func(ctx *core.Context) map[string]any); ok {
+			u.PrepareParams = fn
+			return true
+		}
+	case "preparePath":
+		if fn, ok := val.(func(ctx *core.Context) string); ok {
+			u.PreparePath = fn
+			return true
+		}
+	case "prepareQuery":
+		if fn, ok := val.(func(ctx *core.Context) map[string]any); ok {
+			u.PrepareQuery = fn
+			return true
+		}
+	case "graphqlBody":
+		if fn, ok := val.(func(ctx *core.Context) any); ok {
+			u.GraphqlBody = fn
+			return true
+		}
+	case "graphqlErrors":
+		if fn, ok := val.(func(ctx *core.Context) bool); ok {
+			u.GraphqlErrors = fn
+			return true
+		}
+	case "resultBasic":
+		if fn, ok := val.(func(ctx *core.Context) *core.Result); ok {
+			u.ResultBasic = fn
+			return true
+		}
+	case "resultBody":
+		if fn, ok := val.(func(ctx *core.Context) *core.Result); ok {
+			u.ResultBody = fn
+			return true
+		}
+	case "resultHeaders":
+		if fn, ok := val.(func(ctx *core.Context) *core.Result); ok {
+			u.ResultHeaders = fn
+			return true
+		}
+	case "transformRequest":
+		if fn, ok := val.(func(ctx *core.Context) any); ok {
+			u.TransformRequest = fn
+			return true
+		}
+	case "transformResponse":
+		if fn, ok := val.(func(ctx *core.Context) any); ok {
+			u.TransformResponse = fn
+			return true
+		}
+	}
+	return false
+}

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

@@ -4,6 +4,8 @@ package JAVAPACKAGE.sdktest;
 // utility object's custom map. Mirrors tm/go/test/custom_utility_test.go.
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import static JAVAPACKAGE.sdktest.FeatureHarness.fhMap;
@@ -14,6 +16,7 @@ import java.util.function.Supplier;
 
 import org.junit.jupiter.api.Test;
 
+import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.ProjectNameSDK;
 import JAVAPACKAGE.core.Utility;
 
@@ -56,4 +59,56 @@ public class CustomUtilityTest {
           "custom utility " + key);
     }
   }
+
+  // The half the test above cannot see. Those keys are ALIASES - `auth`,
+  // `body`, `spec` - and no utility member has those names, so landing in
+  // custom is the right outcome for them and the assertion passes whether or
+  // not overriding works at all.
+  //
+  // A key that DOES name a member must replace it. That is the documented
+  // contract, it is what ts does, and it was silently absent here: every entry
+  // went to custom, which nothing reads, so `utility: {"fetcher": ...}` did
+  // nothing while ts honoured it.
+  @Test
+  public void aRealUtilityMemberIsReplacedNotShelved() {
+    int[] reached = {0};
+    Utility.FetcherFn scripted = (ctx, fullurl, fetchdef) -> {
+      reached[0]++;
+      Map<String, Object> out = new LinkedHashMap<>();
+      out.put("status", 200);
+      out.put("statusText", "OK");
+      out.put("headers", new LinkedHashMap<String, Object>());
+      out.put("body", "{}");
+      return out;
+    };
+
+    // The plain constructor, not testSDK. The `test` feature is
+    // transport: 'base' - it REPLACES the transport by design - so a client in
+    // test mode would shadow the scripted fetcher and this would assert
+    // nothing.
+    ProjectNameSDK client = new ProjectNameSDK(fhMap(
+        "utility", fhMap("fetcher", scripted)));
+
+    Utility u = client.getUtility();
+
+    assertNotNull(u.fetcher, "fetcher is null");
+    assertFalse(u.custom.containsKey("fetcher"),
+        "fetcher was shelved in custom instead of replacing the member");
+
+    // Behaviour, not identity: a lambda cannot be compared, so drive it.
+    Context ctx = u.makeContext.apply(
+        new LinkedHashMap<String, Object>(), client.getRootCtx());
+    u.fetcher.fetch(ctx, "http://example.test/probe", new LinkedHashMap<String, Object>());
+    assertEquals(1, reached[0], "the scripted fetcher was not installed");
+  }
+
+  // An unknown key must still be attached rather than dropped, so the two
+  // halves cannot be satisfied by a switch that also swallows extras.
+  @Test
+  public void anUnknownKeyIsStillAttached() {
+    ProjectNameSDK client = new ProjectNameSDK(fhMap(
+        "utility", fhMap("notAUtilityMember", (Supplier<String>) () -> "EXTRA")));
+    assertTrue(client.getUtility().custom.containsKey("notAUtilityMember"),
+        "an unknown utility key was dropped instead of kept in custom");
+  }
 }