@voxgig/sdkgen 4.26.0 → 4.26.1

package/bin/voxgig-sdkgen

@@ -8,7 +8,7 @@ const { Shape, One, Skip } = require('shape')
 
 const { SdkGen } = require('../dist/sdkgen.js')
 
-const VERSION = '4.26.0'
+const VERSION = '4.26.1'
 const KONSOLE = console
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/sdkgen",
-  "version": "4.26.0",
+  "version": "4.26.1",
   "main": "dist/sdkgen.js",
   "type": "commonjs",
   "engines": {

package/project/.sdk/tm/lua/Makefile

@@ -11,8 +11,10 @@
 NATIVE ?=
 -include $(wildcard feature/*/native.mk)
 
+# One Lua state for the whole suite, as the other targets share one process:
+# insulating each file re-requires the SDK and re-decodes its config per file.
 test: build
-	busted -p _test test/
+	busted --no-auto-insulate -p _test test/
 
 build: $(NATIVE)
 	@echo "lua: build complete$(if $(NATIVE), ($(NATIVE)),: no compile step)"

package/project/.sdk/tm/lua/test/option_defaults_test.lua

@@ -0,0 +1,92 @@
+-- ProjectName SDK option defaults test
+--
+-- make_options validates the configured entity defaults once per Lua state
+-- rather than per client: struct's lua getprop scans the parent to classify
+-- it, which made validating n entities cost n^2 on every construction.
+
+local sdk = require("project-name-_sdk")
+local vs = require("utility.struct.struct")
+local schema = require("schema")
+local config = require("config_shared")()
+
+
+local function configured()
+  local names = {}
+  for name, _ in pairs(config.options.entity or {}) do
+    table.insert(names, name)
+  end
+  table.sort(names)
+  return names
+end
+
+
+local function whole(user)
+  local merged = vs.merge({ {}, vs.clone(config.options.entity or {}), vs.clone(user or {}) })
+  local out = vs.validate({ entity = merged }, { entity = schema.OPTSPEC["entity"] })
+  return out.entity
+end
+
+
+describe("make_options entity", function()
+
+  it("matches validating the whole entity map at once", function()
+    assert.are.same(whole(nil), sdk.test().options.entity)
+
+    local name = configured()[1]
+    if name ~= nil then
+      local user = {
+        [name] = { active = true, alias = { a = "b" } },
+        not_configured = { active = true },
+      }
+      assert.are.same(whole(user), sdk.test(nil, { entity = user }).options.entity)
+    end
+  end)
+
+
+  it("keeps each client's entity options its own", function()
+    local name = configured()[1]
+    if name == nil then
+      return
+    end
+    local a = sdk.test()
+    a.options.entity[name].active = true
+    a.options.entity[name].alias.leak = true
+    local b = sdk.test()
+    assert.are.equal(false, b.options.entity[name].active)
+    assert.is_nil(b.options.entity[name].alias.leak)
+  end)
+
+
+  it("validates the configured entity map at most once for many clients", function()
+    local names = configured()
+    local full = 0
+    local validate = vs.validate
+    vs.validate = function(data, spec, injdef)
+      local ent = type(data) == "table" and data.entity or nil
+      if type(ent) == "table" and 1 < #names then
+        local all = true
+        for _, name in ipairs(names) do
+          if ent[name] == nil then
+            all = false
+            break
+          end
+        end
+        if all then
+          full = full + 1
+        end
+      end
+      return validate(data, spec, injdef)
+    end
+
+    local ok, err = pcall(function()
+      for _ = 1, 3 do
+        sdk.test()
+      end
+    end)
+    vs.validate = validate
+
+    assert.is_true(ok, tostring(err))
+    assert.is_true(full <= 1, "entity map validated " .. full .. " times for 3 clients")
+  end)
+
+end)

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

@@ -48,6 +48,40 @@ local function densify_lists(v, seen)
   return v
 end
 
+local function copy_data(v)
+  if type(v) ~= 'table' then
+    return v
+  end
+  local out = {}
+  for k, e in pairs(v) do
+    out[k] = copy_data(e)
+  end
+  return setmetatable(out, getmetatable(v))
+end
+
+-- struct's lua getprop scans every key of the parent to classify it, so
+-- validating a map of n entities costs n^2. Each entity entry validates on its
+-- own, and the config's entries are fixed for this Lua state: validate them
+-- once, and per client only the entries the caller passes.
+local entity_defaults_src = nil
+local entity_defaults = nil
+
+local function validate_entities(entities, spec)
+  local out = vs.validate({ entity = densify_lists(entities) }, { entity = spec })
+  if type(out) == 'table' and type(out.entity) == 'table' then
+    return out.entity
+  end
+  return {}
+end
+
+local function validated_entity_defaults(cfgentity, spec)
+  if entity_defaults_src ~= cfgentity then
+    entity_defaults = validate_entities(vs.clone(cfgentity), spec)
+    entity_defaults_src = cfgentity
+  end
+  return entity_defaults
+end
+
 local function make_options_util(ctx)
   local options = ctx.options or {}
 
@@ -150,6 +184,22 @@ local function make_options_util(ctx)
   -- singleton (see config_shared), and merge would otherwise use its nested
   -- tables as merge TARGETS — one instance's options (server, headers, ...)
   -- would contaminate every instance constructed after it.
+  local cfgentity = cfgopts["entity"]
+  local userentity = opts["entity"]
+  local split = type(cfgentity) == 'table' and vs.ismap(cfgentity)
+    and (userentity == nil or vs.ismap(userentity))
+
+  if split then
+    local rest = {}
+    for k, v in pairs(cfgopts) do
+      if k ~= "entity" then
+        rest[k] = v
+      end
+    end
+    cfgopts = rest
+    opts["entity"] = nil
+  end
+
   local merged = vs.merge({ {}, vs.clone(cfgopts), opts })
 
   -- LUA CANNOT STORE NIL, so `{ a, nil, b }` is a table holding keys 1 and 3
@@ -171,6 +221,21 @@ local function make_options_util(ctx)
   end
   opts = validated
 
+  if split then
+    local entity = copy_data(validated_entity_defaults(cfgentity, optspec["entity"]))
+    if userentity ~= nil then
+      local picked = {}
+      for name, _ in pairs(userentity) do
+        picked[name] = cfgentity[name]
+      end
+      local own = vs.merge({ {}, vs.clone(picked), userentity })
+      for name, e in pairs(validate_entities(own, optspec["entity"])) do
+        entity[name] = e
+      end
+    end
+    opts["entity"] = entity
+  end
+
   -- 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/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.26.0",
+  "version": "4.26.1",
   "provides": {
     "target": [
       "c",