@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/ts/test/live-entity.ts

@@ -5,26 +5,26 @@ import { isControlSkipped, liveDelayMs } from './utility'
 
 // The offline flow keeps its deterministic fixture assertions. Live flows
 // resolve real prerequisites per operation and collect failures until done.
-async function runLiveEntity(setup: any, entity: any, flow: any, accessor: string) {
+async function runLiveEntity(setup: any, entity: any, flow: any, accessor: string, facts: any = {}) {
   const { client, transport } = setup
-  const steps: any[] = flow.step || []
+  const steps: any[] = (flow.step || []).filter((step: any) => false !== step.a)
   const created = new Map<string, any>()
   const listed: any[] = []
   const marks = new Map<string, { name: string, value: any }>()
   const idField = entity.id?.field || 'id'
   const copy = (value: any) => JSON.parse(JSON.stringify(value ?? {}))
-  const hasCreate = steps.some(step => step.op === 'create')
+  const hasCreate = steps.some(step => step.o === 'create')
   const report = await runLiveSteps(steps.map((step, index) => {
-    const ref = step.input?.ref || entity.name + '_ref01'
-    const op = step.op
+    const ref = step.i?.ref || entity.name + '_ref01'
+    const op = step.o
     const excluded = isControlSkipped('entityOp', entity.name + '.' + op, 'live')
     return {
       id: entity.name + '.' + op + '.' + index,
-      cleanup: op === 'remove' || (step.valid || []).some((v: any) => v.apply === 'ItemNotExists'),
+      cleanup: op === 'remove' || (step.v || []).some((v: any) => v.apply === 'ItemNotExists'),
       excluded: excluded.skip ? excluded.reason || 'Excluded by test control' : undefined,
       run: async (context: any) => {
         transport.enter(context)
-        const points = entity.op?.[op]?.points || []
+        const points = (entity.op?.[op]?.points || []).filter((point: any) => false !== point.a)
         if (!points.length) throw new LiveBlocked('No modelled operation point')
         const record = created.get(ref)
         // A failed create must not turn a later update/remove into a write
@@ -41,7 +41,7 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
 
         let input: any = op === 'create'
           ? copy(setup.data.new?.[entity.name]?.[ref]) : {}
-        for (const [name, binding] of Object.entries({ ...step.match, ...step.data })) {
+        for (const [name, binding] of Object.entries({ ...step.m, ...step.d })) {
           const value = setup.idmap[binding as string] ?? setup.idmap[name]
           if (undefined !== value) input[name] = value
         }
@@ -57,34 +57,34 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
         let selected: any
         const missing = new Set<string>()
         for (const point of points) {
-          if (point.select?.$action !== input.$action) continue
+          if (point.q?.$action !== input.$action) continue
           const candidate = { ...input }
           let viable = true
-          const params = point.args?.params || []
-          const query = (point.args?.query || []).filter((arg: any) => arg.reqd)
+          const params = point.g?.params || []
+          const query = (point.g?.query || []).filter((arg: any) => arg.r)
           for (const arg of [...params, ...query]) {
-            if (undefined !== candidate[arg.name] && null !== candidate[arg.name]) continue
-            const key = arg.name === 'id' ? entity.name + '01' : arg.name.replace(/_id$/, '') + '01'
-            const value = setup.idmap[key] ?? setup.idmap[arg.name] ?? loaded?.[arg.name] ?? arg.example
-            if (undefined !== value && null !== value) candidate[arg.name] = value
-            else if (arg.reqd !== false) { viable = false; missing.add(arg.name) }
+            if (undefined !== candidate[arg.n] && null !== candidate[arg.n]) continue
+            const key = arg.n === 'id' ? entity.name + '01' : arg.n.replace(/_id$/, '') + '01'
+            const value = setup.idmap[key] ?? setup.idmap[arg.n] ?? loaded?.[arg.n] ?? arg.ex
+            if (undefined !== value && null !== value) candidate[arg.n] = value
+            else if (arg.r !== false) { viable = false; missing.add(arg.n) }
           }
           if (viable) { resolved = candidate; selected = point; break }
         }
         if (!resolved) throw new LiveBlocked('No usable route; missing arguments: ' + [...missing].join(', '))
         input = resolved
-        if (op === 'create' && selected.contract) {
-          const facts = JSON.parse(selected.contract.json)
-          const request = requestContract(facts)
-          if (request.schema) input = { ...synthesizeInput(request.schema, facts.live?.input ?? request.example) }
-          else if (facts.protocol === 'http') input = {}
-          for (const arg of selected.args?.params || []) if (resolved[arg.name] !== undefined) input[arg.name] = resolved[arg.name]
+        if (op === 'create' && facts[selected.m + ' ' + selected.o]) {
+          const selectedFacts = facts[selected.m + ' ' + selected.o]
+          const request = requestContract(selectedFacts)
+          if (request.schema) input = { ...synthesizeInput(request.schema, selected.li?.input ?? request.example) }
+          else if (selectedFacts.protocol === 'http') input = {}
+          for (const arg of selected.g?.params || []) if (resolved[arg.n] !== undefined) input[arg.n] = resolved[arg.n]
         }
         let intendedMark: { name: string, value: any } | undefined
         if (op === 'update') {
-          for (const spec of step.spec || []) {
-            if (spec.apply === 'TextFieldMark' && step.input?.textfield) {
-              const mark = { name: step.input.textfield, value: spec.def.mark + '_' + setup.now }
+          for (const spec of step.s || []) {
+            if (spec.apply === 'TextFieldMark' && step.i?.textfield) {
+              const mark = { name: step.i.textfield, value: spec.def.mark + '_' + setup.now }
               input[mark.name] = mark.value
               intendedMark = mark
             }
@@ -103,7 +103,7 @@ async function runLiveEntity(setup: any, entity: any, flow: any, accessor: strin
           })
           listed.splice(0, listed.length, ...data)
           context.publish(data)
-          for (const validation of step.valid || []) {
+          for (const validation of step.v || []) {
             const previous = created.get(validation.def?.ref)
             const id = previous?.[idField] ?? previous?.id
             if (undefined === id) continue

package/project/.sdk/tm/ts/test/live-scenarios.ts

@@ -52,9 +52,9 @@ export async function runLiveScenarios(SDK: any, plan: any[], envPrefix: string,
         const explicit = hint.input === undefined ? request.example : resolveRecipe(hint.input, ctx.values)
         let input = request.schema ? synthesizeInput(request.schema, explicit) : explicit ?? {}
         for (const kind of ['params', 'query', 'header', 'cookie']) for (const arg of point.args?.[kind] || []) {
-          if (arg.reqd && input[arg.name] === undefined) {
-            if (arg.example === undefined) throw new LiveBlocked('Missing required argument: ' + arg.name)
-            input[arg.name] = arg.example
+          if (arg.r && input[arg.n] === undefined) {
+            if (arg.ex === undefined) throw new LiveBlocked('Missing required argument: ' + arg.n)
+            input[arg.n] = arg.ex
           }
         }
         const role = hint.auth || (point.facts.security?.length === 0 || point.facts.securitySource === 'unspecified' ? 'public' : 'account')

package/project/.sdk/tm/zig/core/context.zig

@@ -100,7 +100,7 @@ pub const Context = struct {
             ctrl = c;
         } else if (ctxspec.ctrl_obj) |co| {
             ctrl = co;
-        } else if (basectx) |b| {
+        } else if (if (ctxspec.opname == null) basectx else null) |b| {
             ctrl = b.ctrl;
         } else {
             ctrl = Control.make();

package/project/.sdk/tm/zig/core/utility.zig

@@ -1120,7 +1120,7 @@ pub fn prepare_query_util(ctx: *Context) Value {
                     }
                 }
             }
-            if (!h.is_noval(val) and !contained) h.setp(out, key, val);
+            if (!h.is_noval(val) and !std.mem.eql(u8, key, "$action") and !contained) h.setp(out, key, val);
         }
     }
     return out;
@@ -1375,6 +1375,20 @@ pub fn result_body_util(ctx: *Context) ?*SdkResult {
     return result;
 }
 
+// `$action` selects the point (see make_point_util); it is never an API
+// field, so the body is a copy without it. The caller's map is left untouched.
+fn strip_action(reqdata: Value) Value {
+    if (reqdata != .object) return reqdata;
+    if (reqdata.object.get("$action") == null) return reqdata;
+    const body = h.omap();
+    var it = reqdata.object.iterator();
+    while (it.next()) |kv| {
+        const key = kv.key_ptr.*;
+        if (!std.mem.eql(u8, key, "$action")) h.setp(body, key, kv.value_ptr.*);
+    }
+    return body;
+}
+
 pub fn transform_request_util(ctx: *Context) Value {
     const spec = ctx.spec;
     const point = ctx.point;
@@ -1382,16 +1396,16 @@ pub fn transform_request_util(ctx: *Context) Value {
     if (spec) |sp| sp.step = "reqform";
 
     const transform = h.to_map(h.getp(point, "transform"));
-    if (h.is_noval(transform)) return ctx.reqdata;
+    if (h.is_noval(transform)) return strip_action(ctx.reqdata);
 
     const reqform = h.getp(transform, "req");
-    if (h.is_noval(reqform)) return ctx.reqdata;
+    if (h.is_noval(reqform)) return strip_action(ctx.reqdata);
 
     const store = h.jo(&.{.{ "reqdata", ctx.reqdata }});
     // transform now reports collected injection errors beside the value; .out
     // is what it used to return on its own, errors or not.
-    const tres = vs.transform(h.A(), store, reqform) catch return ctx.reqdata;
-    return tres.out;
+    const tres = vs.transform(h.A(), store, reqform) catch return strip_action(ctx.reqdata);
+    return strip_action(tres.out);
 }
 
 pub fn transform_response_util(ctx: *Context) Value {

package/project/.sdk/tm/zig/feature/paging.zig

@@ -3,8 +3,8 @@
 // (or a cursor) into the request query; on the way back (PreResult) it reads
 // the server's pagination signals — a `Link: rel="next"` header,
 // `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records them
-// on `result.paging`. A per-call cursor/page from ctrl takes priority (used by
+// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case forms
+// too) — and records them on `result.paging` and the caller's ctrl paging. A per-call cursor/page from ctrl takes priority (used by
 // auto-iteration). Parameter names (`pageParam`, `limitParam`, `cursorParam`),
 // the page size (`limit`) and the start page (`startPage`, default 1) are
 // configurable.
@@ -114,7 +114,10 @@ pub const PagingFeature = struct {
         if (!h.is_noval(cursor)) {
             h.setp(query, cursor_param, cursor);
         } else if (h.is_noval(h.getp(query, page_param))) {
-            const page = h.getp(paging, "page");
+            // A record written back by pre_result holds the page just fetched
+            // as "page" and the one to fetch as "nextPage", so nextPage wins.
+            var page = h.getp(paging, "nextPage");
+            if (h.is_noval(page)) page = h.getp(paging, "page");
             if (!h.is_noval(page)) {
                 h.setp(query, page_param, page);
             } else {
@@ -257,12 +260,16 @@ pub const PagingFeature = struct {
             }
         }
 
-        // Body-level cursors.
+        // Body-level signals; snake_case forms are read first so camelCase wins.
         if (body == .object) {
             const next = h.getp(body, "next");
             if (!h.is_noval(next) and h.is_noval(h.getp(paging, "next"))) {
                 h.setp(paging, "next", next);
             }
+            const snake_cursor = h.getp(body, "next_cursor");
+            if (!h.is_noval(snake_cursor)) {
+                h.setp(paging, "cursor", snake_cursor);
+            }
             const cursor = h.getp(body, "cursor");
             if (!h.is_noval(cursor)) {
                 h.setp(paging, "cursor", cursor);
@@ -271,6 +278,18 @@ pub const PagingFeature = struct {
             if (!h.is_noval(next_cursor)) {
                 h.setp(paging, "cursor", next_cursor);
             }
+            if (h.is_noval(h.getp(paging, "nextPage"))) {
+                var np = h.getp(body, "nextPage");
+                if (h.is_noval(np)) np = h.getp(body, "next_page");
+                switch (np) {
+                    .integer, .float, .string => h.setp(paging, "nextPage", np),
+                    else => {},
+                }
+            }
+            if (h.get_bool(body, "has_more")) |has_more| {
+                h.setp(paging, "hasMore", h.vbool(has_more));
+                explicit_more = true;
+            }
             if (h.get_bool(body, "hasMore")) |has_more| {
                 h.setp(paging, "hasMore", h.vbool(has_more));
                 explicit_more = true;
@@ -292,6 +311,17 @@ pub const PagingFeature = struct {
 
         result.paging = paging;
         self.last = paging;
+
+        // `.object` is a *MapRef, so the caller's map is refilled in place; a
+        // fresh map on ctrl never reaches the caller.
+        if (ctx.ctrl.paging == .object) {
+            const shared = ctx.ctrl.paging.object;
+            shared.data.clearRetainingCapacity();
+            var it = paging.object.iterator();
+            while (it.next()) |kv| h.setp(ctx.ctrl.paging, kv.key_ptr.*, kv.value_ptr.*);
+        } else {
+            ctx.ctrl.paging = paging;
+        }
     }
 
     fn vname(p: *anyopaque) []const u8 {

package/project/.sdk/tm/zig/feature/test.zig

@@ -109,15 +109,22 @@ fn envelope(ctx: *Context, data: Value) Value {
     const restf = h.getpath(&.{ "transform", "res" }, ctx.point);
     if (restf != .string) return data;
     const spec = restf.string;
-    // Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    // synthesise, so it is left alone rather than guessed at.
+    // Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    // GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     if (spec.len < 8) return data;
     if (!std.mem.startsWith(u8, spec, "`body.")) return data;
     if (!std.mem.endsWith(u8, spec, "`")) return data;
     const inner = spec[6 .. spec.len - 1];
     if (inner.len == 0) return data;
-    if (std.mem.indexOfScalar(u8, inner, '.') != null) return data;
-    return h.jo(&.{.{ inner, data }});
+    var out = data;
+    var end: usize = inner.len;
+    while (true) {
+        const cut = std.mem.lastIndexOfScalar(u8, inner[0..end], '.');
+        const start = if (cut) |c| c + 1 else 0;
+        out = h.jo(&.{.{ inner[start..end], out }});
+        if (cut) |c| end = c else break;
+    }
+    return out;
 }
 
 fn respond(ctx: *Context, status: i64, data: Value, extra: []const h.Pair) Value {
@@ -143,26 +150,62 @@ fn resolve_match(ctx: *Context, explicit: Value) Value {
     return h.omap();
 }
 
+fn point_terminal(p: Value) bool {
+    const parts = h.getp(p, "parts");
+    if (parts != .array) return false;
+    const items = parts.array.data.items;
+    if (items.len == 0) return false;
+    const last = items[items.len - 1];
+    return last == .string and std.mem.startsWith(u8, last.string, "{");
+}
+
+fn point_depth(p: Value) usize {
+    const parts = h.getp(p, "parts");
+    return if (parts == .array) parts.array.data.items.len else 0;
+}
+
+// The entity's own endpoint: a terminal `{param}` marks a record route, and
+// among equals the shallower path wins (the same rule as make_point).
+fn pick_point(points: Value) Value {
+    if (points != .array) return h.vnull();
+    const items = points.array.data.items;
+    if (items.len == 0) return h.vnull();
+    var point = items[0];
+    for (items[1..]) |cand| {
+        if (point_terminal(cand) != point_terminal(point)) {
+            if (point_terminal(cand)) point = cand;
+        } else if (point_depth(cand) < point_depth(point)) {
+            point = cand;
+        }
+    }
+    return point;
+}
+
+fn reqd_names(point: Value, kind: []const u8) Value {
+    const args_path = h.getpath(&.{ "args", kind }, point);
+    const reqd_args = vs.select(h.A(), args_path, h.jo(&.{.{ "reqd", h.vbool(true) }})) catch return h.olist();
+    // transform reports collected injection errors beside the value; .out is
+    // the value itself, errors or not.
+    const tres = vs.transform(h.A(), reqd_args, h.ja(&.{
+        h.vstr("`$EACH`"),
+        h.vstr(""),
+        h.vstr("`$KEY.name`"),
+    })) catch return h.olist();
+    return tres.out;
+}
+
 fn build_args(ctx: *Context, args: Value) Value {
     const op = ctx.op;
     const opname = op.name;
     const entname: []const u8 = if (ctx.entity) |e| e.get_name() else op.entity;
 
     const points = h.getpath(&.{ "entity", entname, "op", opname, "points" }, ctx.config);
-    const point = h.get_elem(points, h.vnum(-1), h.vnull());
-
-    const params_path = h.getpath(&.{ "args", "params" }, point);
-    const reqd_params = vs.select(h.A(), params_path, h.jo(&.{.{ "reqd", h.vbool(true) }})) catch h.olist();
-    const reqd = blk: {
-        // transform now reports collected injection errors beside the value;
-        // .out is what it used to return on its own, errors or not.
-        const tres = vs.transform(h.A(), reqd_params, h.ja(&.{
-            h.vstr("`$EACH`"),
-            h.vstr(""),
-            h.vstr("`$KEY.name`"),
-        })) catch break :blk h.olist();
-        break :blk tres.out;
-    };
+    const point = pick_point(points);
+
+    // Path AND query: a path-only read misses a query-addressed record
+    // (e.g. GET /result?trace_id=), which has no path param at all.
+    const reqd_params = reqd_names(point, "params");
+    const reqd_query = reqd_names(point, "query");
 
     const qand = h.olist();
     const q = h.jo(&.{.{ "`$AND`", qand }});
@@ -171,8 +214,8 @@ fn build_args(ctx: *Context, args: Value) Value {
         const keys = h.keysof_vec(args);
         for (keys) |key| {
             const is_id = std.mem.eql(u8, key, "id");
-            const selected = vs.select(h.A(), reqd, h.vstr(key)) catch h.olist();
-            const is_reqd = !h.is_empty(selected);
+            const is_reqd = !h.is_empty(vs.select(h.A(), reqd_params, h.vstr(key)) catch h.olist()) or
+                !h.is_empty(vs.select(h.A(), reqd_query, h.vstr(key)) catch h.olist());
 
             if (is_id or is_reqd) {
                 const v = ctx.util().param(ctx, h.vstr(key));
@@ -244,20 +287,12 @@ fn test_fetch(entity: Value, ctx: *Context, _: []const u8, _: Value) err.E!Value
         const args = build_args(ctx, update_match);
         const found = vs.select(h.A(), entmap, args) catch h.olist();
         var ent = h.get_elem(found, h.vnum(0), h.vnull());
-        if (h.is_noval(ent) and h.sizeOf(entmap) > 0) {
-            for (h.items_vec(entmap)) |kv| {
-                if (kv.v == .object) {
-                    ent = kv.v;
-                    break;
-                }
-            }
-        }
         if (h.is_noval(ent)) {
+            // update miss: 404, never another record
             return respond(ctx, 404, h.vnull(), &.{.{ "statusText", h.vstr("Not found") }});
         }
         if (ent == .object and reqdata == .object) {
-            var it = reqdata.object.iterator();
-            while (it.next()) |kv| h.setp(ent, kv.key_ptr.*, kv.value_ptr.*);
+            ent = h.merge(h.ja(&.{ ent, reqdata }));
         }
         h.del_prop(ent, h.vstr("$KEY"));
         return respond(ctx, 200, h.clone(ent), &.{});

package/project/sdkgen-package.json

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

package/src/action/doctor.ts

@@ -230,7 +230,7 @@ function orphanModelFiles(actx: ActionContext): string[] {
 
 
 async function doctor(
-  actx: ActionContext, scope?: DoctorScope,
+  actx: ActionContext, scope?: DoctorScope, selected?: string[],
 ): Promise<ActionResult> {
   const log = actx.log
   const fs = actx.fs()
@@ -283,17 +283,18 @@ async function doctor(
       }
 
       if ('target' === kind) {
-        checkTarget(actx, source, report)
+        checkTarget(actx, source, report, selected)
       }
 
       if ('edition' === kind) {
         checkEdition(actx, source, report)
       }
 
-      // Only an ACTIVE feature has source copied out; what an inactive one
-      // left behind is stale, and the target walk reports it as such.
+      // Only an ACTIVE feature has source copied out; an inactive one's
+      // leftovers are stale. `selected` overrides that for the caller's own.
       if ('feature' === kind &&
-        false !== (model as any)?.main?.[KIT]?.feature?.[name]?.active) {
+        (false !== (model as any)?.main?.[KIT]?.feature?.[name]?.active ||
+          true === selected?.includes(name))) {
         checkFeatureSource(actx, source, targets, report)
       }
 
@@ -409,6 +410,7 @@ function resolveDeclared(
 
 function checkTarget(
   actx: ActionContext, resolved: Source, report: DoctorReport,
+  selected?: string[],
 ) {
   const tname = resolved.name
   const tfolder = resolved.folder
@@ -442,14 +444,15 @@ function checkTarget(
       },
     ]
 
-  // The feature set `target add` would select right now. A project that
-  // added its targets before feature trimming existed carries source for
-  // features its model never declared — expected here as STALE, which is
-  // exactly what it is.
+  // The feature set `target add` would select right now, plus any the CALLER
+  // is acting on (`selected`, see COMMENT-NOTES.md). A project that added its
+  // targets before feature trimming existed carries source for features its
+  // model never declared — expected here as STALE, which is what it is.
   const featuremodel: any = model?.main?.[KIT]?.feature ?? {}
   const features = Array.from(new Set([
     'test',
     ...Object.keys(featuremodel).filter((n: string) => false !== featuremodel[n]?.active),
+    ...(selected ?? []),
   ]))
 
   // `folder` and `model` matter: the trim catalogue is resolved consumer-side

package/src/action/edition.ts

@@ -39,6 +39,7 @@ function cmpBase(): string {
 
 const CMD_MAP: any = Object.assign(Object.create(null), {
   add: cmd_edition_add,
+  remove: cmd_edition_remove,
 })
 
 
@@ -65,6 +66,13 @@ async function cmd_edition_add(
 }
 
 
+async function cmd_edition_remove(
+  args: string[], actx: ActionContext,
+): Promise<ActionResult> {
+  return require('./remove').kind_remove('edition', parseAddNames(args), actx)
+}
+
+
 async function edition_add(
   edition: string[], actx: ActionContext,
 ): Promise<ActionResult> {

package/src/action/feature.ts

@@ -42,7 +42,8 @@ import {
 
 
 const CMD_MAP: any = {
-  add: cmd_feature_add
+  add: cmd_feature_add,
+  remove: cmd_feature_remove,
 }
 
 const BASE = 'node_modules/@voxgig/sdkgen'
@@ -74,6 +75,11 @@ async function cmd_feature_add(args: string[], actx: ActionContext): Promise<Act
 }
 
 
+async function cmd_feature_remove(args: string[], actx: ActionContext): Promise<ActionResult> {
+  return require('./remove').kind_remove('feature', parseAddNames(args), actx)
+}
+
+
 async function feature_add(features: string[], actx: ActionContext): Promise<ActionResult> {
 
   // Reuse the caller's Jostraca instance so feature generation honours the