@voxgig/sdkgen 2.0.0 → 2.0.2

package/bin/voxgig-sdkgen

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/sdkgen",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "main": "dist/sdkgen.js",
   "type": "commonjs",
   "engines": {
@@ -25,7 +25,7 @@
     "test": "node --enable-source-maps --test dist-test/**/*.test.js",
     "test-some": "node --enable-source-maps --test-name-pattern=\"$npm_config_pattern\" --test dist-test/**/*.test.js",
     "watch": "tsc --build src test -w",
-    "build": "tsc --build src test && npm run check-scaffold",
+    "build": "tsc --build src test && npm run check-scaffold && npm run stage-scaffold",
     "clean": "rm -rf dist dist-test node_modules yarn.lock package-lock.json",
     "reset": "npm run clean && npm i && npm run build && npm test",
     "embed-version": "node build/version.js",
@@ -38,7 +38,8 @@
     "repo-publish-quick-dry": "npm run build && npm run test && ( npm stage publish --dry-run --registry https://registry.npmjs.org --access=public || echo \"[dry-run] npm stage publish refused (see npm error above) - usually the version is already published; bump package.json before a real release\" )",
     "repo-release": "npm run repo-publish && npm run repo-tag",
     "repo-release-dry": "npm run repo-publish-quick-dry && npm run repo-tag-dry",
-    "check-scaffold": "tsc -p tsconfig.scaffold.json"
+    "check-scaffold": "tsc -p tsconfig.scaffold.json",
+    "stage-scaffold": "node build/scaffold-stage.js && tsc -p tsconfig.scaffold-emit.json"
   },
   "license": "MIT",
   "files": [
@@ -59,12 +60,12 @@
   },
   "peerDependencies": {
     "@tabnas/jsonic": "0.6.0",
-    "@voxgig/apidef": ">=7.0.0 <8",
-    "@voxgig/struct": ">=0.2.1 <0.3",
-    "@voxgig/util": ">=0.5.1 <0.6",
-    "aontu": ">=0.50.1 <0.51",
-    "jostraca": ">=0.31.0 <0.32",
-    "shape": ">=10.1 <11",
+    "@voxgig/apidef": ">=0",
+    "@voxgig/struct": ">=0",
+    "@voxgig/util": ">=0",
+    "aontu": ">=0",
+    "jostraca": ">=0",
+    "shape": ">=0",
     "@tabnas/parser": "0.8.0"
   }
 }

package/project/.sdk/src/cmp/cpp/TestEntity_cpp.ts

@@ -148,6 +148,14 @@ static void ${evar}_entity_instance() {
   ASSERT_EQ(ent->getName(), std::string("${entity.name}"), "entity name");
 }
 
+`)
+
+    // The stream test drives the list op; only emit it when the entity has a
+    // list op (a create/load-only entity has no list endpoint, so
+    // stream("list") throws "Operation \"list\" has no endpoint definitions").
+    const flowHasList = allSteps.some((s: any) => 'list' === s.op)
+    if (flowHasList) {
+      Content(`
 static void ${evar}_entity_stream() {
   // stream() runs the list op through the full pipeline and returns the
   // result items. Seed two entities via test mode; with the streaming feature
@@ -169,7 +177,10 @@ static void ${evar}_entity_stream() {
   std::vector<Value> pitems = pe->stream("list", Value::undef(), Value::undef());
   ASSERT_EQ((int)pitems.size(), 2, "fallback stream yields both items");
 }
+`)
+    }
 
+    Content(`
 static void ${evar}_entity_basic() {
   auto setup = ${evar}_basic_setup(Value::undef());
   std::string mode = setup.live ? "live" : "unit";
@@ -212,8 +223,7 @@ static void ${evar}_entity_basic() {
 
 int main() {
   T_RUN(${evar}_entity_instance);
-  T_RUN(${evar}_entity_stream);
-  T_RUN(${evar}_entity_basic);
+${flowHasList ? `  T_RUN(${evar}_entity_stream);\n` : ''}  T_RUN(${evar}_entity_basic);
   return sdktest::summary("${entity.name}_entity_test");
 }
 `)

package/project/.sdk/src/cmp/dart/Config_dart.ts

@@ -58,6 +58,12 @@ const Config = cmp(async function Config(props: any) {
 
       replace: {
 
+        // Config.fragment.dart carries `'name': 'ProjectName'` — without the
+        // standard replacements the generated SDK reports "ProjectName" as its
+        // own name at runtime. Every sibling dart component already spreads
+        // these; this one did not.
+        ...ctx$.stdrep,
+
         "'AUTHBLOCK'": authBlock,
 
         "'HEADERS'": dartValue(headers, 2),

package/project/.sdk/src/cmp/elixir/ReadmeTopQuick_elixir.ts

@@ -55,14 +55,17 @@ IO.inspect(records)
         .filter((it: any) => !it.optional || it.name === idF)
         .sort((a: any, b: any) =>
           (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
-      const loadArg = 0 < loadItems.length
-        ? `H.deep(%{${loadItems.map((it: any) =>
+      // No required match keys (a singleton endpoint like /current) means no
+      // second argument at all — `load(ent, )` is a syntax error, and
+      // reqmatch defaults to nil, so load/1 is the correct call.
+      const loadArgs = 0 < loadItems.length
+        ? `${eVar}, H.deep(%{${loadItems.map((it: any) =>
           `"${it.name}" => ${elixirLit(it.type,
             it.name === idF ? 'example_id' : 'example_' + it.name)}`).join(', ')}})`
-        : ''
+        : eVar
       Content(`
 # Load a specific ${eName.toLowerCase()} (returns the record, raises on error)
-record = ${Name}.Entity.${eName}.load(${eVar}, ${loadArg})
+record = ${Name}.Entity.${eName}.load(${loadArgs})
 IO.inspect(record)
 `)
     }

package/project/.sdk/src/cmp/lean/Test_lean.ts

@@ -26,6 +26,21 @@ function hasParamFreePoint(op: any): boolean {
 }
 
 
+// True when an op selects a single record by path params — i.e. loading it by
+// id is meaningful. A load whose every point is param-free is a singleton
+// endpoint (`/current`): passing it an id matches no point at all, and the
+// runtime raises `has no matching endpoint`.
+function selectsByParams(op: any): boolean {
+  if (null == op) return false
+  const points = op.points || []
+  for (const pt of points) {
+    const params = ((pt.args || {}).params) || []
+    if (0 < params.length) return true
+  }
+  return false
+}
+
+
 // Synthesize a create payload from the entity's required non-id fields.
 function synthData(fields: any): any {
   const o: any = {}
@@ -64,30 +79,44 @@ const Test = cmp(async function Test(props: any) {
     const Name = e.Name || (e.name.charAt(0).toUpperCase() + e.name.slice(1))
     const ops = e.op || {}
     if (!ops.list && !ops.load) return
-    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
-    (do
-      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
-      if !(← System.FilePath.pathExists seedPath) then
-        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
-      else do
-        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
-        let tclient ← Sdk.testSdk0 seed
-        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
-        let ids ← keysof existing
-        -- list returns every seeded entity
+
+    // Only call the ops the entity actually declares. `Entity.create` is not
+    // generated for a load-only entity, so emitting the create/remove block
+    // unconditionally fails the build with "Unknown identifier X.create".
+    // Value's constructors are spelled out (`Value.list`, not `.list`) — the
+    // expected type is not known at the match scrutinee, and Lean reports the
+    // dotted form as ambiguous against Std's own `.list`.
+    let body = ''
+
+    if (ops.list) {
+      body += `        -- list returns every seeded entity
         let items ← ${ns}.list tclient (← emptyMap) (← emptyMap)
-        let n ← (match items with | .list lid => do pure (← listItems lid).size | _ => pure 0)
+        let n ← (match items with | Value.list lid => do pure (← listItems lid).size | _ => pure 0)
         if n == ids.size then pass s!"${e.name}.list offline -> {n} seeded"
         else fail s!"${e.name}.list offline: got {n}, want {ids.size}"
-        -- load the first seeded entity by id
+`
+    }
+
+    if (ops.load && selectsByParams(ops.load)) {
+      body += `        -- load the first seeded entity by id
         if ids.size > 0 then do
           let wid := ids[0]!
-          let m ← newMap #[("id", .str wid)]
+          let m ← newMap #[("id", Value.str wid)]
           let got ← ${ns}.load tclient m (← emptyMap)
           let gid ← SdkRuntime.gpS got "id"
           if gid == wid then pass s!"${e.name}.load offline (id={wid})"
           else fail s!"${e.name}.load offline: got {gid}, want {wid}"
-        -- create -> load back -> remove, all in the store
+`
+    }
+    // A singleton load (`/current`, `/slack`) is deliberately NOT asserted
+    // here. The offline lane answers from a store keyed by entity id, so a
+    // load carrying no id has nothing to look up — the only honest assertion
+    // would need the model-driven match data the other targets build in their
+    // TestEntity components. Until this lane is model-driven too, such an
+    // entity contributes no offline block rather than a misleading one.
+
+    if (ops.create && ops.load && ops.remove) {
+      body += `        -- create -> load back -> remove, all in the store
         let newmap ← SdkRuntime.gp (← SdkRuntime.gp seed "new") "${e.name}"
         let nks ← keysof newmap
         if nks.size > 0 then do
@@ -95,7 +124,7 @@ const Test = cmp(async function Test(props: any) {
           let created ← ${ns}.create tclient payload (← emptyMap)
           let cid ← SdkRuntime.gpS created "id"
           if cid == "" then fail "${e.name}.create offline returned no id" else do
-            let m2 ← newMap #[("id", .str cid)]
+            let m2 ← newMap #[("id", Value.str cid)]
             let back ← ${ns}.load tclient m2 (← emptyMap)
             if (← SdkRuntime.gpS back "id") == cid then
               pass s!"${e.name}.create/load offline (id={cid})"
@@ -103,8 +132,26 @@ const Test = cmp(async function Test(props: any) {
             let _ ← ${ns}.remove tclient m2 (← emptyMap)
             let gone ← ${ns}.load tclient m2 (← emptyMap)
             match gone with
-            | .map _ => fail s!"${e.name}.remove offline: still present"
-            | _ => pass s!"${e.name}.remove offline (id={cid})")
+            | Value.map _ => fail s!"${e.name}.remove offline: still present"
+            | _ => pass s!"${e.name}.remove offline (id={cid})"
+`
+    }
+
+    // Nothing to assert (an entity whose only op needs path params we cannot
+    // synthesise) — skip the block rather than emit an empty `do`.
+    if ('' === body) return
+
+    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
+    (do
+      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
+      if !(← System.FilePath.pathExists seedPath) then
+        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
+      else do
+        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
+        let tclient ← Sdk.testSdk0 seed
+        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
+        let ids ← keysof existing
+${body})
 `
   })
 
@@ -121,7 +168,7 @@ const Test = cmp(async function Test(props: any) {
     (do
       let items ← ${ns}.list client (← emptyMap) (← emptyMap)
       match items with
-      | .list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
+      | Value.list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
       | _ => fail "${e.name}.list did not return a list")
 `
     }
@@ -151,6 +198,13 @@ const Test = cmp(async function Test(props: any) {
   // The live lane nests two levels deeper than the offline lane.
   const liveBlocks = blocks.split('\n').map((l) => l ? '  ' + l : l).join('\n')
 
+  // A `do` block whose last statement is a `let` is a type error in Lean
+  // ("the rest of the do block has monadic result type"), and an entirely
+  // empty one does not parse at all. An API whose entities offer no op these
+  // lanes can drive leaves both empty, so terminate them explicitly.
+  const offlineBody = '' === offline ? '    pure ()\n' : offline
+  const liveBody = '' === blocks ? '      pure ()\n' : liveBlocks
+
   Folder({ name: 'test' }, () => {
   File({ name: 'Runner.' + target.ext }, () => {
     Content(`-- ${model.const.Name} SDK test runner (generated by @voxgig/sdkgen).
@@ -183,14 +237,14 @@ def main : IO UInt32 := do
   let liveBase ← IO.getEnv "SDK_TEST_BASE"
   let ctx ← mkCtx
   let offline : SIO Unit := do
-${offline}  offline.run ctx
+${offlineBody}  offline.run ctx
   match liveBase with
   | none => IO.println "skip - live lane (set SDK_TEST_BASE to enable)"
   | some base => do
     let live : SIO Unit := do
       let opts ← newMap #[("base", .str base)]
       let client ← Sdk.newSdk opts
-${liveBlocks}    live.run ctx
+${liveBody}    live.run ctx
   let p ← npass.get
   let f ← nfail.get
   IO.println ""

package/project/.sdk/src/cmp/py/Test_py.ts

@@ -29,7 +29,10 @@ const Test = cmp(function Test(props: any) {
 
     // Generate exists test
     File({ name: 'test_exists.' + target.ext }, () => {
-      Content(`# ProjectName SDK exists test
+      // The header names the SDK like every other line here — a literal
+      // `ProjectName` is the raw placeholder, not a substituted value: Content
+      // does not apply the standard replacements.
+      Content(`# ${model.const.Name} SDK exists test
 
 import pytest
 from ${model.const.Name.toLowerCase()}_sdk import ${model.const.Name}SDK

package/project/.sdk/tm/c/utility/graphql.c

@@ -72,7 +72,7 @@ const char* graphql_error_code(voxgig_value* gqlerr) {
 // generated create/update call look exactly like its REST equivalent.
 voxgig_value* graphql_body_util(Context* ctx) {
   voxgig_value* gql = getp(ctx->point, "graphql");
-  if (!voxgig_is_map(gql)) return voxgig_new_noval();
+  if (!voxgig_is_map(gql)) return voxgig_new_undef();
 
   // reqmatch/reqdata hold the caller's arguments for THIS call; data/match
   // hold the entity's current state. Which pair depends on whether the op

package/project/.sdk/tm/kotlin/core/Utility.kt

@@ -82,6 +82,8 @@ class Utility private constructor(register: Boolean) {
     u.prepareParams = this.prepareParams
     u.preparePath = this.preparePath
     u.prepareQuery = this.prepareQuery
+    u.graphqlBody = this.graphqlBody
+    u.graphqlErrors = this.graphqlErrors
     u.resultBasic = this.resultBasic
     u.resultBody = this.resultBody
     u.resultHeaders = this.resultHeaders

package/project/.sdk/tm/lean/Makefile

@@ -0,0 +1,25 @@
+.PHONY: test build lint clean corpus
+
+# Build every lean_lib and lean_exe declared in lakefile.toml.
+build:
+	lake build
+
+# Run the four generated test executables. `runner` drives the SDK pipeline
+# and the generated entity/direct tests, `feature` the feature suite,
+# `primary` the shared primary-utility corpus, and `structcorpus` the
+# vendored voxgig/struct corpus. Any one exiting non-zero fails the target.
+test:
+	lake exe runner
+	lake exe feature
+	lake exe primary
+	lake exe structcorpus
+
+corpus:
+	lake exe structcorpus
+
+# "Lint": a clean build means the code type-checks.
+lint:
+	lake build
+
+clean:
+	rm -rf .lake

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

@@ -231,13 +231,13 @@ def prepareQuery (ctx : Value) : SIO Value := do
     if !(isNov v) && !(names.contains k) then sp out k v
   pure out
 
+/-- Assemble the path template from `point.parts`. This is `struct.join` with
+the url flag — NOT a plain intercalate: empty segments are dropped (a doubled
+slash changes the URL and 404s on strict routers) and there is no leading
+slash, because makeUrl joins base/prefix/path/suffix with `joinurl`. -/
 def preparePath (ctx : Value) : SIO String := do
   let point ← gp ctx "point"
-  match (← gp point "parts") with
-  | .list i => do
-    let segs := (← listItems i).map vs
-    pure ("/" ++ String.intercalate "/" segs.toList)
-  | _ => pure ""
+  join (← gp point "parts") (sep := .str "/") (url := true)
 
 /-- The API definition is authoritative: a POST-only or PATCH-based API
 exposes `update` as POST or PATCH, not the PUT the op name implies. Only
@@ -396,9 +396,11 @@ def graphqlBody (ctx : Value) : SIO Value := do
       match spec with
       | .map _ => do
         let name ← gpS spec "name"
-        let from ← gpS spec "from"
+        -- `from` is a Lean keyword, so the binding cannot take the field's
+        -- own name.
+        let varFrom ← gpS spec "from"
         if name != "" then
-          if from == "" then do
+          if varFrom == "" then do
             -- The input object IS the request body. Strip the action
             -- selector, which is an SDK-side point discriminator, not an API
             -- field.
@@ -409,8 +411,8 @@ def graphqlBody (ctx : Value) : SIO Value := do
           else do
             -- Only send variables the caller actually supplied: sending an
             -- explicit null would clear a field on many APIs.
-            let v0 ← gp reqsrc from
-            let v ← if isNullish v0 then gp datasrc from else pure v0
+            let v0 ← gp reqsrc varFrom
+            let v ← if isNullish v0 then gp datasrc varFrom else pure v0
             if !(isNullish v) then sp variables name v
       | _ => pure ()
     newMap #[("query", ← gp gql "doc"), ("variables", variables)]

package/project/.sdk/tm/lean/test/TPrimaryUtility.lean

@@ -306,9 +306,12 @@ def main : IO UInt32 := do
     -- The remaining corpus sections. They carry no cases in this project's
     -- corpus, but are driven here so any future fixture runs against Lean too.
 
+    -- clean takes (ctx, val), so the fixture supplies `args`, not `in` —
+    -- same shape as param/makeError above.
     runset "clean" (← getSpec primary #["clean", "basic"]) fun entry => do
-      let ctx ← entryCtx entry opts config
-      pure ((← SdkUtility.clean ctx (← SdkUtility.gp entry "in")), none)
+      let args ← SdkUtility.gp entry "args"
+      let ctx ← mapCtx entry (← argAt args 0) opts config
+      pure ((← SdkUtility.clean ctx (← argAt args 1)), none)
 
     runset "makeResult" (← getSpec primary #["makeResult", "basic"]) fun entry => do
       pure ((← SdkUtility.makeResult (← entryCtx entry opts config)), none)