@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/src/cmp/zig/TestClean_zig.ts

@@ -40,7 +40,7 @@ const TestClean = cmp(function TestClean(props: any) {
       const method = zigVarName(e.name)
       const cls = entityClassName(e, entityColl)
       Object.keys(e.op || {})
-        .filter((op) => ['list', 'load', 'create', 'update', 'remove'].includes(op))
+        .filter((op) => ['list', 'load', 'create', 'update', 'patch', 'remove'].includes(op))
         .sort((a, b) => ((rank[a] ?? 2) - (rank[b] ?? 2)) || a.localeCompare(b))
         .forEach((op) => candidates.push({
           method, mod: method, cls, op, params: pointParams(configEntity[e.name]?.op?.[op]),
@@ -79,26 +79,27 @@ function zigstr(s: string): string {
 
 function candidateFn(c: Candidate): string {
   const name = 'try_' + c.method + '_' + c.op
-  const call = 'client.' + c.method + '(vnull()).' + c.op + '(mtch, ctrl)'
   if ('list' === c.op) {
     return `
 fn ${name}(client: *sdk.SDK, mtch: Value, ctrl: Value) Outcome {
-    switch (${call}) {
+    const ent = client.${c.method}(vnull());
+    switch (ent.list(mtch, ctrl)) {
         .ok => |ents| {
             const records = h.olist();
             for (ents) |e| records.array.append(e.asEntity().data(null)) catch {};
-            return .{ .ok = true, .err = null, .result = records };
+            return .{ .ok = true, .err = null, .result = records, .match = ent.asEntity().matchv(null) };
         },
-        .err => |e| return .{ .ok = false, .err = e, .result = vnull() },
+        .err => |e| return .{ .ok = false, .err = e, .result = vnull(), .match = ent.asEntity().matchv(null) },
     }
 }
 `
   }
   return `
 fn ${name}(client: *sdk.SDK, mtch: Value, ctrl: Value) Outcome {
-    switch (${call}) {
-        .ok => |ent| return .{ .ok = true, .err = null, .result = ent.asEntity().data(null) },
-        .err => |e| return .{ .ok = false, .err = e, .result = vnull() },
+    const ent = client.${c.method}(vnull());
+    switch (ent.${c.op}(mtch, ctrl)) {
+        .ok => |res| return .{ .ok = true, .err = null, .result = res.asEntity().data(null), .match = ent.asEntity().matchv(null) },
+        .err => |e| return .{ .ok = false, .err = e, .result = vnull(), .match = ent.asEntity().matchv(null) },
     }
 }
 `
@@ -107,7 +108,7 @@ fn ${name}(client: *sdk.SDK, mtch: Value, ctrl: Value) Outcome {
 
 function streamFn(c: Candidate): string {
   return `
-fn stream_${c.method}_${c.op}(client: *sdk.SDK, mtch: Value, callopts: Value) []Value {
+fn stream_${c.method}_${c.op}(client: *sdk.SDK, mtch: Value, callopts: Value) sdk.StreamResult {
     return client.${c.method}(vnull()).stream("${c.op}", mtch, callopts);
 }
 `
@@ -298,7 +299,7 @@ const ThrowFeature = struct {
 };
 
 // A stream that succeeds, so the pipeline's terminal step never runs. A zig
-// stream producer has no error channel, so no stream fails.
+// stream producer has no error channel; a stream fails only at a step.
 const StreamOkFeature = struct {
     var instance: u8 = 0;
 
@@ -438,7 +439,18 @@ const Transport = struct {
     }
 };
 
+// Offline, as every generated suite is: the test OPTION resolves a required
+// server variable to test-<name>, and installs no transport.
+fn offline(options: Value) Value {
+    h.setp(options, "test", h.jo(&.{.{ "active", h.vbool(true) }}));
+    return options;
+}
+
 fn makeSdk(scenario: Scenario, sinks: *Sinks, clean_active: bool, extra: ?sdk.Feature) *sdk.SDK {
+    return makeSdkWith(scenario, sinks, clean_active, extra, vnull());
+}
+
+fn makeSdkWith(scenario: Scenario, sinks: *Sinks, clean_active: bool, extra: ?sdk.Feature, auth: Value) *sdk.SDK {
     const feature = h.omap();
     if (fh.fh_has_feature("log")) h.setp(feature, "log", h.jo(&.{.{ "active", h.vbool(true) }}));
     if (fh.fh_has_feature("debug")) h.setp(feature, "debug", h.jo(&.{
@@ -463,14 +475,15 @@ fn makeSdk(scenario: Scenario, sinks: *Sinks, clean_active: bool, extra: ?sdk.Fe
     const clean = h.jo(&.{.{ "values", h.vstr(CANARY_VALUE) }});
     if (!clean_active) h.setp(clean, "active", h.vbool(false));
 
-    const options = h.jo(&.{
+    const options = offline(h.jo(&.{
         .{ "apikey", h.vstr(CANARY_APIKEY) },
         .{ "secret", h.vstr(CANARY_SECRET) },
         .{ "headers", h.jo(&.{.{ "X-Custom-Token", h.vstr(CANARY_HEADER) }}) },
         .{ "clean", clean },
         .{ "feature", feature },
         .{ "system", h.jo(&.{.{ "fetch", Transport.make(scenario) }}) },
-    });
+    }));
+    if (auth == .object) h.setp(options, "auth", auth);
 
     if (extra) |f| return sdk.SDK.new_with(options, &.{ CaptureFeature.make(sinks), f });
     return sdk.SDK.new_with(options, &.{CaptureFeature.make(sinks)});
@@ -482,10 +495,12 @@ const Outcome = struct {
     ok: bool,
     err: ?*sdk.h.SdkError,
     result: Value,
+    // The match the entity holds once the operation returns.
+    match: Value,
 };
 
 const Candidate = *const fn (client: *sdk.SDK, mtch: Value, ctrl: Value) Outcome;
-const Streamer = *const fn (client: *sdk.SDK, mtch: Value, callopts: Value) []Value;
+const Streamer = *const fn (client: *sdk.SDK, mtch: Value, callopts: Value) sdk.StreamResult;
 ${candidates.map(candidateFn).join('')}${candidates.map(streamFn).join('')}
 const CandidateDef = struct { run: Candidate, stream: Streamer, params: []const []const u8 };
 
@@ -505,10 +520,10 @@ fn usableOp() ?Target {
         const filled = h.omap();
         for (cand.params) |p| h.setp(filled, p, h.vstr("p1"));
         for ([_]Value{ h.omap(), filled }) |mtch| {
-            const plain = sdk.SDK.new(h.jo(&.{
+            const plain = sdk.SDK.new(offline(h.jo(&.{
                 .{ "apikey", h.vstr(CANARY_APIKEY) },
                 .{ "system", h.jo(&.{.{ "fetch", Transport.make(.ok) }}) },
-            }));
+            })));
             if (cand.run(plain, h.clone(mtch), h.omap()).ok) {
                 return .{ .run = cand.run, .stream = cand.stream, .mtch = mtch };
             }
@@ -525,6 +540,8 @@ fn drive(client: *sdk.SDK, target: Target, ctrl: Value, sinks: *Sinks) ?*sdk.h.S
     const out = target.run(client, h.clone(target.mtch), ctrl);
     if (out.err) |e| sinks.err("error", e);
     if (out.ok) sinks.value("result", out.result);
+    // Raw, as a caller copying the match into another query reads it.
+    sinks.value("match", out.match);
     const explain = h.getp(ctrl, "explain");
     if (explain == .object) sinks.value("explain", explain);
     if (held == .object and (explain != .object or held.object != explain.object)) {
@@ -586,14 +603,19 @@ test "clean: no credential leaves the SDK in any form" {
         }
     }
 
+    // A name given at run time replaces the declared one: the match leaves
+    // out whichever name prepare_auth placed.
+    _ = drive(makeSdkWith(.ok, &sinks, true, null, h.jo(&.{.{ "name", h.vstr("zzcred") }})),
+        target, h.omap(), &sinks);
+
     // A credential mistyped as a map. The zig validator's failure is not
     // raised (make_options keeps its input), so what the constructor produced
     // is swept instead: a string quoting the value, cleaned the way a
     // validation message is.
-    const mistyped = sdk.SDK.new(h.jo(&.{
+    const mistyped = sdk.SDK.new(offline(h.jo(&.{
         .{ "apikey", h.jo(&.{.{ "value", h.vstr(CANARY_APIKEY) }}) },
         .{ "clean", h.jo(&.{.{ "values", h.vstr(CANARY_VALUE) }}) },
-    }));
+    })));
     sinks.push("mistyped:quoted", sdk.utilmod.clean_str_util(
         mistyped.get_root_ctx(),
         fmt("apikey: expected string, got {{\\"value\\":\\"{s}\\"}}", .{CANARY_APIKEY}),
@@ -605,12 +627,22 @@ test "clean: no credential leaves the SDK in any form" {
     try testing.expect(hookerr != null);
 
     // The explain record a stream call is passed is cleaned however the
-    // stream ends: from a feature's producer, or materialised by done. A zig
-    // stream hands no error back, so the record is what is asserted on.
-    for ([_]?sdk.Feature{ StreamOkFeature.make(), null }, [_][]const u8{ "stream-ok", "stream-plain" }) |extra, name| {
+    // stream ends: from a feature's producer, materialised by done, or
+    // failed, when the error it returns is swept as well.
+    for (
+        [_]?sdk.Feature{ StreamOkFeature.make(), null, null },
+        [_]Scenario{ .ok, .ok, .notfound },
+        [_][]const u8{ "stream-ok", "stream-plain", "stream-fail" },
+    ) |extra, scenario, name| {
         const explain = h.omap();
         const callopts = h.jo(&.{.{ "ctrl", h.jo(&.{.{ "explain", explain }}) }});
-        _ = target.stream(makeSdk(.ok, &sinks, true, extra), h.clone(target.mtch), callopts);
+        switch (target.stream(makeSdk(scenario, &sinks, true, extra), h.clone(target.mtch), callopts)) {
+            .ok => try testing.expect(scenario == .ok),
+            .err => |e| {
+                try testing.expect(scenario != .ok);
+                sinks.err(fmt("{s}:error", .{name}), e);
+            },
+        }
         try testing.expect(0 < explain.object.count());
         sinks.value(fmt("{s}:explain", .{name}), explain);
     }
@@ -621,12 +653,12 @@ test "clean: no credential leaves the SDK in any form" {
     try testing.expect(denied != null);
 
     // A client given no clean block at all masks by the schema defaults.
-    const bare = sdk.SDK.new(h.jo(&.{
+    const bare = sdk.SDK.new(offline(h.jo(&.{
         .{ "apikey", h.vstr(CANARY_APIKEY) },
         .{ "secret", h.vstr(CANARY_SECRET) },
         .{ "headers", h.jo(&.{.{ "X-Custom-Token", h.vstr(CANARY_HEADER) }}) },
         .{ "system", h.jo(&.{.{ "fetch", Transport.make(.notfound) }}) },
-    }));
+    })));
     const barerr = drive(bare, target, h.omap(), &sinks);
     try testing.expect(barerr != null);
 
@@ -710,9 +742,9 @@ test "clean: the sweep can see a leak: clean switched off shows the credential"
 }
 
 test "clean: a registered value used as a property name is masked, collisions kept" {
-    const client = sdk.SDK.new(h.jo(&.{
+    const client = sdk.SDK.new(offline(h.jo(&.{
         .{ "clean", h.jo(&.{.{ "values", h.vstr("ZZVAL-abc123,ZZVAL-xyz789") }}) },
-    }));
+    })));
     const out = sdk.utilmod.clean_util(client.get_root_ctx(), h.jo(&.{
         .{ "ZZVAL-abc123", h.vnum(1) },
         .{ "ZZVAL-xyz789", h.vnum(2) },
@@ -753,9 +785,10 @@ test "clean: the generated config's own clean block is honoured" {
 // A feature's name is not a field name: a feature called secrets does not
 // make its settings secret, though a sensitive field inside it still is. An
 // entity block, of per-entity settings or seeded records keyed by entity name
-// and id, is not read at all.
+// and id, is not read at all, and nor are rbac's rules, keyed by entity and
+// operation names.
 test "clean: a feature's name is read as a name" {
-    const client = sdk.SDK.new(h.jo(&.{
+    const client = sdk.SDK.new(offline(h.jo(&.{
         .{ "apikey", h.vstr(CANARY_APIKEY) },
         .{ "feature", h.jo(&.{
             .{ "secrets", h.jo(&.{
@@ -763,6 +796,10 @@ test "clean: a feature's name is read as a name" {
                 .{ "name", h.vstr("ZZNAME-feat123") },
                 .{ "token", h.vstr("ZZTOKEN-feat456") },
             }) },
+            .{ "rbac", h.jo(&.{
+                .{ "active", h.vbool(false) },
+                .{ "rules", h.jo(&.{.{ "zztoken.load", h.vstr("PLAINRULE-k7j5h3g1") }}) },
+            }) },
             .{ "test", h.jo(&.{
                 .{ "active", h.vbool(false) },
                 .{ "entity", h.jo(&.{.{ "zztoken", h.jo(&.{.{ "ZZTOKEN01", h.jo(&.{
@@ -773,7 +810,7 @@ test "clean: a feature's name is read as a name" {
         .{ "entity", h.jo(&.{.{ "zztoken", h.jo(&.{.{ "alias", h.jo(&.{
             .{ "zzkey", h.vstr("PLAINALIAS-m2n4b6v8") },
         }) }}) }}) },
-    }));
+    })));
     const ctx = client.get_root_ctx();
     try testing.expectEqualStrings("ZZNAME-feat123 " ++ MASK,
         sdk.utilmod.clean_str_util(ctx, "ZZNAME-feat123 ZZTOKEN-feat456"));
@@ -781,6 +818,8 @@ test "clean: a feature's name is read as a name" {
         sdk.utilmod.clean_str_util(ctx, "record PLAINRECORD-t5r3e1w9"));
     try testing.expectEqualStrings("alias PLAINALIAS-m2n4b6v8",
         sdk.utilmod.clean_str_util(ctx, "alias PLAINALIAS-m2n4b6v8"));
+    try testing.expectEqualStrings("rule PLAINRULE-k7j5h3g1",
+        sdk.utilmod.clean_str_util(ctx, "rule PLAINRULE-k7j5h3g1"));
 }
 `
 }

package/project/.sdk/src/cmp/zig/TestEntity_zig.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content } from '@voxgig/sdkgen'
+import { cmp, Content, invalidRequest, opReachable } from '@voxgig/sdkgen'
 
 import { zigVarName } from './utility_zig'
 
@@ -10,7 +10,9 @@ const TestEntity = cmp(function TestEntity(props: any) {
   const method = zigVarName(entity.name)
   const ops = entity.op || {}
 
-  if (ops.load) {
+  // Each smoke test calls with only what it shows, so a bare call must reach
+  // a route: an id for load, nothing for list.
+  if (opReachable(ops.load, ['id'])) {
     Content(`
 test "${method}_load_smoke" {
     const fixture = h.jo(&.{.{ "${entity.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
@@ -37,7 +39,7 @@ test "${method}_load_smoke" {
 `)
   }
 
-  if (ops.list) {
+  if (opReachable(ops.list, [])) {
     Content(`
 test "${method}_list_smoke" {
     const fixture = h.jo(&.{.{ "${entity.name}", h.jo(&.{.{ "t01", h.jo(&.{.{ "id", h.vstr("t01") }}) }}) }});
@@ -60,13 +62,60 @@ test "${method}_stream_smoke" {
     const testsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), sdkopts);
     const e = testsdk.${method}(vnull());
     const items = e.stream("list", vnull(), vnull());
-    try std.testing.expect(items.len == 2);
+    try std.testing.expect(items == .ok and items.ok.len == 2);
 
     // Fallback: streaming inactive still yields both materialised items.
     const plainsdk = sdk.test_sdk(h.jo(&.{.{ "entity", fixture }}), vnull());
     const pe = plainsdk.${method}(vnull());
     const pitems = pe.stream("list", vnull(), vnull());
-    try std.testing.expect(pitems.len == 2);
+    try std.testing.expect(pitems == .ok and pitems.ok.len == 2);
+}
+
+test "${method}_stream_error" {
+    const offline = h.jo(&.{.{ "net", h.jo(&.{.{ "offline", h.vbool(true) }}) }});
+    switch (sdk.test_sdk(offline, vnull()).${method}(vnull()).stream("list", vnull(), vnull())) {
+        .err => |er| try std.testing.expect(std.mem.indexOf(u8, er.msg, "offline") != null),
+        .ok => try std.testing.expect(false),
+    }
+
+    const quiet = h.jo(&.{.{ "ctrl", h.jo(&.{.{ "throw", h.vbool(false) }}) }});
+    try std.testing.expect(sdk.test_sdk(offline, vnull()).${method}(vnull()).stream("list", vnull(), quiet) == .ok);
+
+    if (fh.fh_has_feature("rbac")) {
+        const deny = h.jo(&.{.{ "feature", h.jo(&.{.{ "rbac", h.jo(&.{
+            .{ "active", h.vbool(true) },
+            .{ "deny", h.vbool(true) },
+        }) }}) }});
+        switch (sdk.test_sdk(vnull(), deny).${method}(vnull()).stream("list", vnull(), vnull())) {
+            .err => |er| try std.testing.expect(std.mem.eql(u8, er.code, "rbac_denied")),
+            .ok => try std.testing.expect(false),
+        }
+    }
+}
+
+test "${method}_stream_ctrl" {
+    const explain = h.omap();
+    const ctrl = h.jo(&.{.{ "explain", explain }});
+    _ = sdk.test_sdk(vnull(), vnull()).${method}(vnull()).stream("list", vnull(), h.jo(&.{.{ "ctrl", ctrl }}));
+    try std.testing.expect(h.is_noval(h.getp(ctrl, "stream")));
+    try std.testing.expect(0 < explain.object.count());
+}
+`)
+  }
+
+  const bad = invalidRequest(entity)
+  if (null != bad) {
+    const args = Object.entries(bad.args).map(([k, v]) => `.{ ${JSON.stringify(k)}, ` +
+      ('number' === typeof v ? `h.vnum(${v})` : 'boolean' === typeof v ? `h.vbool(${v})` :
+        `h.vstr(${JSON.stringify(v)})`) + ' }').join(', ')
+    Content(`
+test "${method}_validate" {
+    if (!fh.fh_has_feature("validate")) return error.SkipZigTest;
+    const opts = h.jo(&.{.{ "feature", h.jo(&.{.{ "validate", h.jo(&.{.{ "active", h.vbool(true) }}) }}) }});
+    switch (sdk.test_sdk(vnull(), opts).${method}(vnull()).${bad.op}(h.jo(&.{ ${args} }), vnull())) {
+        .err => |er| try std.testing.expect(std.mem.eql(u8, er.code, "validate_failed")),
+        .ok => try std.testing.expect(false),
+    }
 }
 `)
   }

package/project/.sdk/src/cmp/zig/Test_zig.ts

@@ -26,6 +26,7 @@ const Test = cmp(function Test(props: any) {
 
 const std = @import("std");
 const sdk = @import("sdk");
+const fh = @import("fh.zig");
 const h = sdk.h;
 const Value = sdk.Value;
 

package/project/.sdk/src/cmp/zig/fragment/Entity.fragment.zig

@@ -14,6 +14,7 @@ const Context = ctxmod.Context;
 const CtxSpec = ctxmod.CtxSpec;
 const Utility = utility_mod.Utility;
 const OpResult = types.OpResult;
+const StreamResult = types.StreamResult;
 const OutVal = types.OutVal;
 const Entity = types.Entity;
 
@@ -147,23 +148,34 @@ pub const EntyClass = struct {
         return self.doneResult(ctx);
     }
 
-    // A step's error ends the stream empty without reaching done, so the
-    // explain record is cleaned here.
-    fn streamFail(utility: *Utility, ctx: *Context) []Value {
-        utility.clean_explain(ctx);
-        return &.{};
+    // What make_error or done hands back, as a stream: the error, or under
+    // `throw: false` the data there is.
+    fn streamItems(res: OpResult) StreamResult {
+        const data = switch (res) {
+            .err => |e| return .{ .err = e },
+            .ok => |v| v,
+        };
+        if (data == .array) {
+            return .{ .ok = data.array.data.items };
+        } else if (!h.is_noval(data)) {
+            var out: std.ArrayList(Value) = .empty;
+            out.append(h.A(), data) catch {};
+            return .{ .ok = out.toOwnedSlice(h.A()) catch &.{} };
+        }
+        return .{ .ok = &.{} };
     }
 
     /// Streaming operation. Runs `action` through the full pipeline and
-    /// returns a slice of the result items, so the `streaming` feature's
-    /// incremental output is reachable from a generated entity (a normal op
-    /// call materialises the whole result). This runtime is synchronous and
-    /// zig has no built-in lazy iterators, so the returned slice is a
-    /// materialised cursor the caller walks. `callopts` parameterises the
-    /// call: inbound yields the streaming feature's items when active, else
-    /// the materialised items; outbound attaches an iterable `body` to the
-    /// request (reqdata `body$`); `ctrl` threads pipeline control.
-    pub fn stream(self: *EntyClass, action: []const u8, args: Value, callopts: Value) []Value {
+    /// returns the result items, so the `streaming` feature's incremental
+    /// output is reachable from a generated entity (a normal op call
+    /// materialises the whole result). This runtime is synchronous and zig
+    /// has no built-in lazy iterators, so the items are a materialised slice
+    /// the caller walks; a failed operation is `.err`, as an operation's is.
+    /// `callopts` parameterises the call: inbound yields the streaming
+    /// feature's items when active, else the materialised items; outbound
+    /// attaches an iterable `body` to the request (reqdata `body$`); `ctrl`
+    /// threads pipeline control.
+    pub fn stream(self: *EntyClass, action: []const u8, args: Value, callopts: Value) StreamResult {
         const utility = self.utility;
 
         const stream_opts: Value = switch (callopts) {
@@ -171,10 +183,13 @@ pub const EntyClass = struct {
             else => h.omap(),
         };
 
-        const ctrl: Value = switch (h.to_map(h.getp(stream_opts, "ctrl"))) {
-            .object => h.to_map(h.getp(stream_opts, "ctrl")),
-            else => h.omap(),
-        };
+        // A copy: the caller's ctrl gains no key, and explain stays its own record.
+        const ctrl = h.omap();
+        const given = h.to_map(h.getp(stream_opts, "ctrl"));
+        if (given == .object) {
+            var it = given.object.iterator();
+            while (it.next()) |kv| h.setp(ctrl, kv.key_ptr.*, kv.value_ptr.*);
+        }
         h.setp(ctrl, "stream", stream_opts);
 
         const reqmatch: Value = switch (args) {
@@ -203,25 +218,26 @@ pub const EntyClass = struct {
         }
 
         // Run the same pipeline as run_op, firing the feature hooks (the
-        // streaming feature attaches result.stream on PreResult).
+        // streaming feature attaches result.stream on PreResult). A failed
+        // step leaves through make_error, as an operation's does.
         utility.feature_hook(ctx, "PrePoint");
-        const point = utility.make_point(ctx) catch return streamFail(utility, ctx);
+        const point = utility.make_point(ctx) catch return streamItems(self.opError(ctx));
         ctx.out_set("point", OutVal{ .val = point });
 
         utility.feature_hook(ctx, "PreSpec");
-        const spec = utility.make_spec(ctx) catch return streamFail(utility, ctx);
+        const spec = utility.make_spec(ctx) catch return streamItems(self.opError(ctx));
         ctx.out_set("spec", OutVal{ .spec = spec });
 
         utility.feature_hook(ctx, "PreRequest");
-        const resp = utility.make_request(ctx) catch return streamFail(utility, ctx);
+        const resp = utility.make_request(ctx) catch return streamItems(self.opError(ctx));
         ctx.out_set("request", OutVal{ .response = resp });
 
         utility.feature_hook(ctx, "PreResponse");
-        const resp2 = utility.make_response(ctx) catch return streamFail(utility, ctx);
+        const resp2 = utility.make_response(ctx) catch return streamItems(self.opError(ctx));
         ctx.out_set("response", OutVal{ .response = resp2 });
 
         utility.feature_hook(ctx, "PreResult");
-        const result = utility.make_result(ctx) catch return streamFail(utility, ctx);
+        const result = utility.make_result(ctx) catch return streamItems(self.opError(ctx));
         ctx.out_set("result", OutVal{ .result = result });
 
         utility.feature_hook(ctx, "PreDone");
@@ -232,19 +248,11 @@ pub const EntyClass = struct {
             if (res.stream) |sf| {
                 // done() does not run on this path, so its record is cleaned here.
                 utility.clean_explain(ctx);
-                return sf.call(sf.ctx);
+                return .{ .ok = sf.call(sf.ctx) };
             }
         }
 
-        const data = utility.done(ctx) catch return &.{};
-        if (data == .array) {
-            return data.array.data.items;
-        } else if (!h.is_noval(data)) {
-            var out: std.ArrayList(Value) = .empty;
-            out.append(h.A(), data) catch {};
-            return out.toOwnedSlice(h.A()) catch &.{};
-        }
-        return &.{};
+        return streamItems(self.doneResult(ctx));
     }
 
     // ---- Entity interface ----
@@ -322,5 +330,7 @@ pub const EntyClass = struct {
 
     // #UpdateOp
 
+    // #PatchOp
+
     // #RemoveOp
 };

package/project/.sdk/src/cmp/zig/fragment/EntityPatchOp.fragment.zig

@@ -0,0 +1,26 @@
+// EJECT-START
+
+pub fn patch(self: *EntyClass, reqdata: Value, ctrl: Value) EntResult {
+    const ctx = self.utility.make_context(CtxSpec{
+        .opname = "patch",
+        .ctrl = ctrl,
+        .mtch = self.mtch,
+        .data = self.data,
+        .reqdata = reqdata,
+    }, self.ent_ctx());
+    return self.run_op_ent(ctx, patch_post_done);
+}
+
+fn patch_post_done(self: *EntyClass, ctx: *Context) void {
+    if (ctx.result) |result| {
+        const resmatch = result.resmatch;
+        const resdata = result.resdata;
+        if (resmatch == .object) self.mtch = resmatch;
+        if (!h.is_noval(resdata)) {
+            const cm = h.to_map(h.clone(resdata));
+            self.data = if (cm == .object) cm else h.omap();
+        }
+    }
+}
+
+// EJECT-END

package/project/.sdk/src/cmp/zig/fragment/Main.fragment.zig

@@ -161,9 +161,22 @@ pub const ProjectNameSDK = struct {
         const path = h.get_str(fetchargs, "path") orelse "";
         const method: []const u8 = blk: {
             const m = h.get_str(fetchargs, "method");
-            break :blk if (m) |mm| (if (mm.len == 0) "GET" else mm) else "GET";
+            const given = if (m) |mm| (if (mm.len == 0) "GET" else mm) else "GET";
+            break :blk std.ascii.allocUpperString(h.A(), given) catch given;
         };
 
+        // The root context holds the failure, where direct() reads it.
+        const allow_method = h.getpath(&.{ "allow", "method" }, options);
+        if (!h.allow_list_has(allow_method, method)) {
+            const shown: []const u8 = switch (allow_method) {
+                .string => |text| text,
+                else => "",
+            };
+            return self.get_root_ctx().fail("spec_method_allow", std.fmt.allocPrint(h.A(),
+                "Method \"{s}\" not allowed by SDK option allow.method value: \"{s}\"",
+                .{ method, shown }) catch "");
+        }
+
         const params: Value = switch (h.to_map(h.getp(fetchargs, "params"))) {
             .object => h.to_map(h.getp(fetchargs, "params")),
             else => h.omap(),
@@ -213,11 +226,7 @@ pub const ProjectNameSDK = struct {
 
     // Is this raw-access op permitted by the SDK's allow.op option?
     fn op_allowed(self: *ProjectNameSDK, op: []const u8) bool {
-        const allow: []const u8 = switch (h.getpath(&.{ "allow", "op" }, self.options)) {
-            .string => |s| s,
-            else => "",
-        };
-        return std.mem.indexOf(u8, allow, op) != null;
+        return h.allow_list_has(h.getpath(&.{ "allow", "op" }, self.options), op);
     }
 
     fn op_denied(self: *ProjectNameSDK, op: []const u8) Value {
@@ -292,6 +301,21 @@ pub const ProjectNameSDK = struct {
                 break :blk if (jf == .function) h.call_json(jf) else h.vnull();
             };
 
+            if (!no_body and (h.get_bool(fetched, "unreadable") orelse false)) {
+                const failed: ?*errmod.ProjectNameError = if (200 <= status and status < 300) null else ctx.make_error(
+                    "request_status",
+                    std.fmt.allocPrint(h.A(), "request: {d}: {s}", .{ status, h.get_str(fetched, "statusText") orelse "" }) catch "",
+                );
+                const body_err = utility_mod.unreadable_body(ctx, status, headers, h.getp(fetched, "body"), h.getp(fetchdef, "headers"), failed);
+                return h.jo(&.{
+                    .{ "ok", h.vbool(false) },
+                    .{ "status", h.vnum(status) },
+                    .{ "headers", headers },
+                    .{ "data", json_data },
+                    .{ "err", h.vstr(self.sdkUtility.clean_str(ctx, body_err.msg)) },
+                });
+            }
+
             return h.jo(&.{
                 .{ "ok", h.vbool(200 <= status and status < 300) },
                 .{ "status", h.vnum(status) },

package/project/.sdk/src/cmp/zig/fragment/Root.fragment.zig

@@ -22,6 +22,7 @@ pub const test_sdk = sdk.test_sdk;
 
 pub const Value = helpers.Value;
 pub const OpResult = types.OpResult;
+pub const StreamResult = types.StreamResult;
 pub const Feature = types.Feature;
 pub const OutVal = types.OutVal;
 pub const Context = context.Context;

package/project/.sdk/src/cmp/zig/utility_zig.ts

@@ -4,6 +4,8 @@ import {
   walk,
 } from '@voxgig/struct'
 
+import { canonScalarKey, requiredItems } from '@voxgig/sdkgen'
+
 
 // Zig keywords that are illegal as a plain identifier.
 const ZIG_RESERVED = new Set<string>([
@@ -138,8 +140,19 @@ function clean(o: any, dropDefaults?: boolean): any {
   return prune(o, true === dropDefaults)
 }
 
+// A list's required route and query parameters, as the match it is called with.
+function zigListMatch(entity: any): string {
+  const lit = (type: any): string =>
+    (({ NULL: 'h.vnull()', INTEGER: 'h.vnum(1)', NUMBER: 'h.vnum(1)', BOOLEAN: 'h.vbool(true)', ARRAY: 'h.olist()', OBJECT: 'h.omap()' }) as any)[canonScalarKey(type)] ?? 'h.vstr("example")'
+  const items = requiredItems(entity, 'list')
+  return 0 < items.length
+    ? `h.jo(&.{${items.map((it: any) => `.{ ${JSON.stringify(it.name)}, ${lit(it.type)} }`).join(', ')}})`
+    : 'h.vnull()'
+}
+
 
 export {
+  zigListMatch,
   clean,
   formatZigValue,
   zigModuleName,

package/project/.sdk/tm/c/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -81,7 +81,8 @@ static Operation* resolve_op(Context* ctx, const char* opname) {
   }
 
   const char* input =
-      (strcmp(opname, "update") == 0 || strcmp(opname, "create") == 0) ? "data" : "match";
+      (strcmp(opname, "update") == 0 || strcmp(opname, "create") == 0 ||
+       strcmp(opname, "patch") == 0) ? "data" : "match";
 
   voxgig_value* targets = getp(opcfg, "points");
   if (!voxgig_is_list(targets)) targets = voxgig_new_list();