@voxgig/sdkgen 4.23.0 → 4.24.1

package/project/.sdk/tm/ts/test/pipeline.test.ts

@@ -317,6 +317,11 @@ describe('pipeline:feature order', () => {
 })
 
 
+// A cookie credential as prepareAuth writes it: `<scheme>=K` for the probe
+// key, with no scheme prefix and nothing else in the bag.
+const COOKIE_PAIR = /^[^=;]+=K$/
+
+
 describe('pipeline:prepareAuth', () => {
 
   function authCtx(options: any, spec: any) {
@@ -327,19 +332,42 @@ describe('pipeline:prepareAuth', () => {
     return { headers: {} as any, query: {} as any }
   }
 
+  // `basic: false` is explicit: an HTTP Basic API's generated config carries
+  // `auth.basic: true`, and a client that merges it in takes a branch needing
+  // a secret as well. With none supplied that branch writes nothing, which
+  // the probe below would then read as a public API.
+  function auth(prefix: string): any {
+    return { prefix, basic: false }
+  }
+
   // Run prepareAuth with both containers present and see which one the
   // generated utility writes to, and under what name. Null means this SDK
-  // places no credential at all — a public API — which is a legitimate
-  // shape, and the tests below assert exactly that instead.
-  const CRED = (() => {
-    const ctx = authCtx({ apikey: 'K', auth: { prefix: 'Bearer' } }, bags())
+  // places no credential at all — a public API — which the cases below then
+  // assert instead.
+
+  // `pair` is the `<scheme>=` lead-in of a COOKIE credential, which rides the
+  // header bag under the key `cookie` rather than taking a header of its own.
+  function probe(options: any) {
+    const ctx = authCtx(options, bags())
     ;(stdutil as any).prepareAuth(ctx)
     for (const where of ['headers', 'query'] as const) {
       const name = Object.keys(ctx.spec[where] as any)[0]
-      if (null != name) return { where, name, value: ctx.spec[where][name] }
+      if (null == name) continue
+      const value = ctx.spec[where][name]
+      const pair = COOKIE_PAIR.test(String(value)) && 'cookie' === name && 'headers' === where
+        ? String(value).slice(0, -1)
+        : ''
+      return { where, name, value, pair }
     }
     return null
-  })()
+  }
+
+  const CRED = probe({ apikey: 'K', auth: auth('Bearer') })
+
+  // Every credential this SDK could possibly place: both credentials and
+  // Basic switched on, so whichever branch the API has, something lands
+  // unless the API is public.
+  const ANY = probe({ apikey: 'K', secret: 'S', auth: { prefix: 'Bearer', basic: true } })
 
   function placed(options: any, seed?: any) {
     const spec: any = bags()
@@ -350,27 +378,40 @@ describe('pipeline:prepareAuth', () => {
   }
 
   test('guards a missing spec', () => {
-    strictEqual((stdutil as any).prepareAuth(authCtx({ auth: { prefix: '' }, apikey: 'K' }, null)).code, 'auth_no_spec')
+    strictEqual((stdutil as any).prepareAuth(authCtx({ auth: auth(''), apikey: 'K' }, null)).code, 'auth_no_spec')
+  })
+
+  // Without this the cases below cannot fail for an SDK whose credential the
+  // probe misses: every one of them takes the public-API path instead.
+  test('the probe finds the credential this SDK places', () => {
+    strictEqual(null != CRED, null != ANY)
   })
 
   test('the apikey is placed where this API puts it', () => {
     if (null == CRED) {
       // A public API places nothing, and that is the whole assertion.
-      strictEqual(placed({ apikey: 'K', auth: { prefix: 'Bearer' } }), undefined)
+      strictEqual(placed({ apikey: 'K', auth: auth('Bearer') }), undefined)
       return
     }
     ok('headers' === CRED.where || 'query' === CRED.where)
+    if ('' !== CRED.pair) {
+      // A cookie credential is a `<scheme>=<key>` pair, and the scheme name
+      // leaves no room for the option's prefix.
+      ok(COOKIE_PAIR.test(String(CRED.value)), String(CRED.value))
+      return
+    }
     // A header credential is prefix-joined; a query credential is the raw
     // key, because a query parameter has nowhere to put a scheme name.
     strictEqual(CRED.value, 'headers' === CRED.where ? 'Bearer K' : 'K')
   })
 
   test('a raw apikey (empty prefix) goes in as-is', () => {
-    strictEqual(placed({ apikey: 'K', auth: { prefix: '' } }), null == CRED ? undefined : 'K')
+    const raw = null == CRED ? undefined : CRED.pair + 'K'
+    strictEqual(placed({ apikey: 'K', auth: auth('') }), raw)
   })
 
   test('an empty apikey drops the credential', () => {
-    strictEqual(placed({ apikey: '', auth: { prefix: 'Bearer' } }, 'stale'), undefined)
+    strictEqual(placed({ apikey: '', auth: auth('Bearer') }, 'stale'), undefined)
   })
 
   test('a public API (no auth block) drops the credential', () => {
@@ -378,7 +419,7 @@ describe('pipeline:prepareAuth', () => {
   })
 
   test('a missing apikey option drops the credential', () => {
-    strictEqual(placed({ auth: { prefix: 'Bearer' } }, 'stale'), undefined)
+    strictEqual(placed({ auth: auth('Bearer') }, 'stale'), undefined)
   })
 })
 

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.1",
   "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