@voxgig/sdkgen 4.31.1 → 4.32.1

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

@@ -764,6 +764,15 @@ pub fn make_url_util(ctx: *Context) E![]const u8 {
         h.vstr(spec.suffix),
     }), "/", true) catch "";
 
+    // A route the definition ends with a slash keeps it: a server such as a
+    // Django REST one redirects or refuses the route without it.
+    const orig = h.getp(ctx.point, "orig");
+    if (orig == .string and std.mem.endsWith(u8, orig.string, "/") and spec.suffix.len == 0 and
+        !std.mem.endsWith(u8, url, "/"))
+    {
+        url = std.mem.concat(h.A(), u8, &.{ url, "/" }) catch url;
+    }
+
     const resmatch = h.omap();
 
     if (spec.params == .object) {
@@ -1043,12 +1052,37 @@ pub fn prepare_headers_util(ctx: *Context) Value {
     const options: Value = if (ctx.client) |client| client.options_map() else ctx.options;
 
     const headers = h.getp(options, "headers");
-    if (h.is_noval(headers)) return h.omap();
-
-    return switch (h.clone(headers)) {
+    const out: Value = if (h.is_noval(headers)) h.omap() else switch (h.clone(headers)) {
         .object => h.clone(headers),
         else => h.omap(),
     };
+
+    // A header parameter travels as a header, under the name the definition
+    // gives it, and only from this call's own arguments. It replaces a default
+    // of the same name, whatever its case.
+    const aheader: Value = h.getpath(&.{ "args", "header" }, ctx.point);
+    if (aheader == .array) {
+        for (aheader.array.data.items) |hd| {
+            const name = h.getp(hd, "name");
+            if (name != .string or name.string.len == 0) continue;
+            const orig = h.getp(hd, "orig");
+            const wire: []const u8 = if (orig == .string and orig.string.len != 0) orig.string else name.string;
+            var val = h.getp(ctx.reqmatch, name.string);
+            if (h.is_noval(val)) val = h.getp(ctx.reqdata, name.string);
+            if (h.is_noval(val)) continue;
+            const key = std.ascii.allocLowerString(h.A(), wire) catch wire;
+            while (true) {
+                var kit = out.object.iterator();
+                const same: ?[]const u8 = while (kit.next()) |kv| {
+                    if (std.ascii.eqlIgnoreCase(kv.key_ptr.*, key)) break kv.key_ptr.*;
+                } else null;
+                _ = out.object.fetchOrderedRemove(same orelse break);
+            }
+            h.setp(out, key, h.vstr(h.stringify(val)));
+        }
+    }
+
+    return out;
 }
 
 pub fn prepare_body_util(ctx: *Context) Value {
@@ -1094,6 +1128,16 @@ pub fn prepare_path_util(ctx: *Context) []const u8 {
     return vs.join(h.A(), parts, "/", true) catch "";
 }
 
+// Whether a list of argument definitions names this key.
+fn names_key(defs: Value, key: []const u8) bool {
+    if (defs != .array) return false;
+    for (defs.array.data.items) |d| {
+        const name = h.getp(d, "name");
+        if (name == .string and std.mem.eql(u8, name.string, key)) return true;
+    }
+    return false;
+}
+
 pub fn prepare_query_util(ctx: *Context) Value {
     const point = ctx.point;
     const reqmatch: Value = switch (ctx.reqmatch) {
@@ -1107,6 +1151,8 @@ pub fn prepare_query_util(ctx: *Context) Value {
     // A path parameter travels in the path. The generated config lists them
     // as args.params, which prepare_params reads; params is the older list.
     const aparams: Value = h.getpath(&.{ "args", "params" }, point);
+    // A header parameter travels in the headers, which prepare_headers fills.
+    const aheader: Value = h.getpath(&.{ "args", "header" }, point);
     // A query parameter travels under the name the definition gives it, its
     // orig, which the model may have renamed for the caller.
     const aquery: Value = h.getpath(&.{ "args", "query" }, point);
@@ -1126,15 +1172,7 @@ pub fn prepare_query_util(ctx: *Context) Value {
                     }
                 }
             }
-            if (!contained and aparams == .array) {
-                for (aparams.array.data.items) |pd| {
-                    const name = h.getp(pd, "name");
-                    if (name == .string and std.mem.eql(u8, name.string, key)) {
-                        contained = true;
-                        break;
-                    }
-                }
-            }
+            if (!contained) contained = names_key(aparams, key) or names_key(aheader, key);
             var wire: []const u8 = key;
             if (aquery == .array) {
                 for (aquery.array.data.items) |qd| {
@@ -1406,13 +1444,33 @@ pub fn result_body_util(ctx: *Context) ?*SdkResult {
 // `$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 {
+    return omit_keys(reqdata, h.vnull(), true);
+}
+
+// A header argument travels as a header, which prepare_headers_util sends, so
+// the body is built from the request data without it.
+fn dropped(key: []const u8, point: Value, action: bool) bool {
+    if (action) return std.mem.eql(u8, key, "$action");
+    const aheader: Value = h.getpath(&.{ "args", "header" }, point);
+    if (aheader != .array) return false;
+    for (aheader.array.data.items) |hd| {
+        const name = h.getp(hd, "name");
+        if (name == .string and std.mem.eql(u8, name.string, key)) return true;
+    }
+    return false;
+}
+
+fn omit_keys(reqdata: Value, point: Value, action: bool) Value {
     if (reqdata != .object) return reqdata;
-    if (reqdata.object.get("$action") == null) return reqdata;
-    const body = h.omap();
+    var found = false;
     var it = reqdata.object.iterator();
-    while (it.next()) |kv| {
+    while (it.next()) |kv| found = found or dropped(kv.key_ptr.*, point, action);
+    if (!found) return reqdata;
+    const body = h.omap();
+    var bit = reqdata.object.iterator();
+    while (bit.next()) |kv| {
         const key = kv.key_ptr.*;
-        if (!std.mem.eql(u8, key, "$action")) h.setp(body, key, kv.value_ptr.*);
+        if (!dropped(key, point, action)) h.setp(body, key, kv.value_ptr.*);
     }
     return body;
 }
@@ -1423,16 +1481,18 @@ pub fn transform_request_util(ctx: *Context) Value {
 
     if (spec) |sp| sp.step = "reqform";
 
+    const reqdata = omit_keys(ctx.reqdata, point, false);
+
     const transform = h.to_map(h.getp(point, "transform"));
-    if (h.is_noval(transform)) return strip_action(ctx.reqdata);
+    if (h.is_noval(transform)) return strip_action(reqdata);
 
     const reqform = h.getp(transform, "req");
-    if (h.is_noval(reqform)) return strip_action(ctx.reqdata);
+    if (h.is_noval(reqform)) return strip_action(reqdata);
 
-    const store = h.jo(&.{.{ "reqdata", ctx.reqdata }});
+    const store = h.jo(&.{.{ "reqdata", 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 strip_action(ctx.reqdata);
+    const tres = vs.transform(h.A(), store, reqform) catch return strip_action(reqdata);
     return strip_action(tres.out);
 }
 

package/project/sdkgen-package.json

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

package/src/helpers/definitionPlan.ts

@@ -5,6 +5,7 @@ import { KIT, nom } from '@voxgig/apidef'
 import { entityCollection } from './opShape'
 import { pointSegments } from './pointPath'
 import { pointFacts } from './resolved'
+import { isAuthSuppressed, resolveAuthIn, resolveAuthName } from '../utility'
 
 
 // What a generated definition test checks an operation against: the API
@@ -23,6 +24,7 @@ type DefinitionPoint = {
   action?: string
   args: { name: string, wire: string, value: any }[]
   select: Record<string, any>
+  headers: { name: string, wire: string, value: any }[]
   query: string[]
   auth: Credential[][] | null
   status: number
@@ -31,6 +33,10 @@ type DefinitionPoint = {
 }
 
 
+// The operations every target generates a method for. The model may hold
+// others, such as a patch beside an update, which no SDK can be called with.
+const GENERATED_OPS = ['load', 'list', 'create', 'update', 'remove']
+
 const MAX_ITEMS = 3
 const MAX_DEPTH = 8
 const MAX_SAMPLE = 32 * 1024
@@ -41,13 +47,19 @@ function definitionPlan(ctx$: any): DefinitionPoint[] {
   const plan: DefinitionPoint[] = []
   const unchecked = false === model?.main?.[KIT]?.config?.auth?.active ||
     false === model?.main?.[KIT]?.info?.auth
+  // A generated SDK sends one credential, under the scheme apidef chose for it.
+  const own = model?.main?.[KIT]?.info?.security?.scheme
+  // The header the SDK puts any key in, as its prepareAuth does, though the
+  // definition declares no scheme: LearnWorlds declares it as a parameter.
+  const ownHeader = !isAuthSuppressed(model) && 'header' === resolveAuthIn(model) ?
+    resolveAuthName(model).toLowerCase() : null
 
   for (const entity of Object.values(entityCollection(model)) as any[]) {
     if (false === entity.active) continue
 
     for (const [op, operation] of Object.entries(entity.op || {}) as any[]) {
       // An inactive operation stays in the model but gets no method.
-      if (false === operation?.active) continue
+      if (false === operation?.active || !GENERATED_OPS.includes(op)) continue
 
       const points = (operation?.points || []).filter((p: any) => false !== p.a)
 
@@ -71,9 +83,21 @@ function definitionPlan(ctx$: any): DefinitionPoint[] {
           return { name: arg.n, wire, value: scalar(def?.example ?? def?.schema?.example) ?? 'p' + (i + 1) }
         })
 
+        // A header argument is sent too, and must arrive as a header under
+        // the definition's name, never in the query.
+        const headers = (point.g?.header || [])
+          .filter((arg: any) => false !== arg.a &&
+            ![ownHeader, 'content-type'].includes(String(arg.or || arg.n).toLowerCase()))
+          .map((arg: any, i: number) => {
+            const wire = String(arg.or || arg.n)
+            const def = params.find((p: any) => 'header' === p?.in &&
+              wire.toLowerCase() === String(p?.name).toLowerCase())
+            return { name: arg.n, wire, value: scalar(arg.ex ?? def?.example ?? def?.schema?.example) ?? 'h' + (i + 1) }
+          })
+
         const selected: Record<string, any> = {}
         for (const key of select.exist || []) {
-          if (args.some((a: any) => a.name === key)) continue
+          if (args.some((a: any) => a.name === key) || headers.some((h: any) => h.name === key)) continue
           const def = params.find((p: any) => key === p?.name)
           selected[key] = scalar(def?.example ?? def?.schema?.example) ?? 'v1'
         }
@@ -101,10 +125,11 @@ function definitionPlan(ctx$: any): DefinitionPoint[] {
           ...(null == select.$action ? {} : { action: select.$action }),
           args,
           select: selected,
+          headers,
           query: params.filter((p: any) => 'query' === p?.in).map((p: any) => p.name),
-          auth: unchecked ? null : credentialSets(facts),
+          auth: unchecked ? null : credentialSets(facts, own),
           status: success?.status ?? 200,
-          sample: null == media ? null : boundedSample(sampleOf(media)),
+          sample: null == media ? null : boundedSample(fitting(sampleOf(media), media.schema)),
           idField: entity.id?.field || 'id',
         })
       }
@@ -168,6 +193,20 @@ function sampleOf(media: any): any {
 }
 
 
+// An example whose top level contradicts its own schema proves nothing, such
+// as GitHub's page of deployment rule apps written as a list of its halves.
+function fitting(sample: any, schema: any): any {
+  const type = Array.isArray(schema?.type) ?
+    schema.type.find((t: string) => 'null' !== t) : schema?.type
+  const object = 'object' === type || (null == type && null != schema?.properties)
+  const array = 'array' === type || (null == type && null != schema?.items)
+  if (object && (Array.isArray(sample) || null == sample || 'object' !== typeof sample)) {
+    return undefined
+  }
+  return array && !Array.isArray(sample) ? undefined : sample
+}
+
+
 // Schema-shaped data where the definition gives no example: every property,
 // one item per array, the first branch of a union.
 function synthesize(schema: any, depth: number): any {
@@ -222,15 +261,18 @@ function boundedSample(sample: any): any {
 
 
 // Alternatives of credentials, every one of a set needed together. Empty is a
-// public operation; null is one whose schemes no SDK option can express.
-function credentialSets(facts: any): Credential[][] | null {
+// public operation; null is one whose schemes no SDK option can express. Only
+// those the SDK's one scheme meets count, so Petstore's OAuth pets are null.
+function credentialSets(facts: any, own?: string): Credential[][] | null {
   const security = facts.security
   if (!Array.isArray(security) || 0 === security.length) return []
   if (security.some((req: any) => null == req || 0 === Object.keys(req).length)) return []
 
+  const reqs = 'string' === typeof own && '' !== own ?
+    security.filter((req: any) => Object.keys(req).every((name) => name === own)) : security
   const schemes = facts.securitySchemes || {}
   const sets: Credential[][] = []
-  for (const req of security) {
+  for (const req of reqs) {
     const set = Object.keys(req).map((name) => credentialOf(schemes[name]))
     if (set.every((c) => null != c)) sets.push(set as Credential[])
   }