@voxgig/sdkgen 4.23.0 → 4.24.0

package/project/.sdk/tm/ts/src/feature/paging/PagingFeature.ts

@@ -22,7 +22,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreRequest(this: any, ctx: any) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const spec = ctx.spec
@@ -51,7 +51,10 @@ class PagingFeature extends BaseFeature {
       spec.query[cursorParam] = paging.cursor
     }
     else if (null == spec.query[pageParam]) {
-      spec.query[pageParam] = null != paging.page ? paging.page : (this._options.startPage || 1)
+      // A record written back by PreResult holds the page just fetched as
+      // `page` and the one to fetch as `nextPage`, so nextPage wins.
+      spec.query[pageParam] = null != paging.nextPage ? paging.nextPage :
+        null != paging.page ? paging.page : (this._options.startPage || 1)
     }
 
     if (null != this._options.limit && null == spec.query[limitParam]) {
@@ -61,7 +64,7 @@ class PagingFeature extends BaseFeature {
 
 
   PreResult(this: any, ctx: any) {
-    if (!this._isList(ctx)) {
+    if (!this.active || !this._isList(ctx)) {
       return
     }
     const result = ctx.result
@@ -118,8 +121,17 @@ class PagingFeature extends BaseFeature {
 
     if (body && 'object' === typeof body) {
       if (null != body.next) { paging.next = paging.next || body.next }
+      if (null != body.next_cursor) { paging.cursor = body.next_cursor }
       if (null != body.cursor) { paging.cursor = body.cursor }
       if (null != body.nextCursor) { paging.cursor = body.nextCursor }
+      if (null == paging.nextPage) {
+        const np = null != body.nextPage ? body.nextPage : body.next_page
+        if ('number' === typeof np || 'string' === typeof np) { paging.nextPage = np }
+      }
+      if ('boolean' === typeof body.has_more) {
+        paging.hasMore = body.has_more
+        explicitMore = true
+      }
       if ('boolean' === typeof body.hasMore) {
         paging.hasMore = body.hasMore
         explicitMore = true
@@ -138,6 +150,10 @@ class PagingFeature extends BaseFeature {
 
     result.paging = paging
 
+    if (null != ctx.ctrl) {
+      ctx.ctrl.paging = paging
+    }
+
     const client: any = this._client
     client._paging = { last: paging }
   }

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -193,6 +193,7 @@ class TestFeature extends BaseFeature {
         const found = select(entmap, args)
         const ent = getelem(found, 0)
         if (null == ent) {
+          // update miss: 404, never another record
           return respond(404, undefined, { statusText: S_NOT_FOUND })
         }
         else {
@@ -237,6 +238,8 @@ class TestFeature extends BaseFeature {
         const out = clone(ent)
         return respond(200, out)
       }
+
+      return respond(404, undefined, { statusText: 'Unknown operation' })
     }
 
     // Optional network behaviour simulation over the mock transport. Enable

package/project/.sdk/tm/ts/src/utility/PrepareQueryUtility.ts

@@ -16,7 +16,7 @@ function prepareQuery(ctx: Context) {
 
   const out: any = {}
   for (let [key, val] of items(reqmatch)) {
-    if (null != val && !params.includes(key)) {
+    if (null != val && '$action' !== key && !params.includes(key)) {
       out[key] = val
     }
   }

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

@@ -206,6 +206,7 @@ describe('FeatureCorpus', () => {
 
       const probe: any = makeClient({})
       if (!probe._rootctx.config.hasFeature(name)) {
+        t.diagnostic(`feature.${name}: inert (this SDK does not generate the feature)`)
         return t.skip(`this SDK was generated without the ${name} feature`)
       }
 

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

@@ -150,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 }});
@@ -178,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));
@@ -251,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.23.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