@voxgig/sdkgen 4.22.0 → 4.23.0

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 {

package/project/sdkgen-package.json

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

package/src/cmp/ReadmeTop.ts

@@ -192,7 +192,7 @@ Learn more about Voxgig SDKs at [voxgig.com/sdk](${VOXGIG_SDK}).
     // Named here, in one line, with the detail left to each target's README.
     const features = featureDocs(model)
     if (0 < features.length) {
-      Content(`> **Features:** ${features.map((f: any) => '`' + f.name + '`').join(', ')} — opt-in,
+      Content(`> **Features:** ${features.map((f: any) => '`' + f.n + '`').join(', ')} — opt-in,
 > inactive until switched on, and configured per client. See the Features
 > section of any SDK README below for what each one does.
 

package/src/cmp/ReadmeUnions.ts

@@ -28,7 +28,7 @@ const ReadmeUnions = cmp(function ReadmeUnions(props: any) {
       }
       rows.push({
         entity: ent.name,
-        field: field.name,
+        field: field.n,
         branches: union.branches,
         depth: union.depth,
       })

package/src/cmp/Test.ts

@@ -27,7 +27,7 @@ const Test = cmp(function Test(props: any) {
     const supported = ['ts', 'js'].includes(target.name)
     File({ name: 'live-coverage.json' }, () => Content(JSON.stringify({
       version: 1, target: target.name, scenarios: supported ? 'supported' : 'unsupported',
-      points: points.map(point => point.contract?.id || point.method + ' ' + point.orig),
+      points: points.map(point => point.co?.id || point.m + ' ' + point.o),
       ...(!supported ? { reason: 'This target does not yet execute declarative live recipes. Its existing tests do not establish full operation coverage.' } : {}),
     }, null, 2)))
     if (!supported) log.warn({ point: 'live-scenarios-unsupported', note: 'Declarative live recipes are not executed by target ' + target.name })

package/src/helpers/buildIdNames.ts

@@ -26,24 +26,24 @@ function buildIdNames(entity: EntityLike, flow: FlowLike): string[] {
 
   const ancestors: string[] = (entity.relations?.ancestors || []).flat()
   for (const anc of ancestors) {
-    for (let i = 1; i <= COUNT; i++) push(`${anc}0${i}`)
+    for (let i = 1; i <= COUNT; i++) push(`${entityRelationName(anc)}0${i}`)
   }
 
   const steps = Array.isArray(flow?.step)
     ? flow.step
     : Object.values(flow?.step || {})
-  for (const step of steps) {
-    if (step?.match) {
-      for (const v of Object.values(step.match)) {
+  for (const step of steps.filter((s: any) => false !== s.a)) {
+    if (step?.m) {
+      for (const v of Object.values(step.m)) {
         if (typeof v === 'string' && v && !v.endsWith('$')) push(v)
       }
     }
-    // step.data values can also be aliased via setup (e.g. update step.data
+    // step.d values can also be aliased via setup (e.g. update step.d
     // = {data_type_id: 'data_type01'} → setup adds idmap[data_type_id] =
     // idmap[data_type01]). The right-hand side `data_type01` must be in the
     // idmap or the alias resolves to undefined.
-    if (step?.data) {
-      for (const v of Object.values(step.data)) {
+    if (step?.d) {
+      for (const v of Object.values(step.d)) {
         if (typeof v === 'string' && v && !v.endsWith('$')) push(v)
       }
     }
@@ -53,6 +53,16 @@ function buildIdNames(entity: EntityLike, flow: FlowLike): string[] {
 }
 
 
+function entityRelationName(ref: string): string {
+  return ref.startsWith('$.main.kit.entity.') ? ref.slice('$.main.kit.entity.'.length) : ref
+}
+
+function flowSteps(flow: FlowLike): any[] {
+  return Object.values(flow?.step || {}).filter((step: any) => false !== step.a)
+}
+
 export {
   buildIdNames,
+  entityRelationName,
+  flowSteps,
 }

package/src/helpers/canonSpec.ts

@@ -101,10 +101,10 @@ function entityDataSpec(ent: any): Record<string, any> {
 
   const fields = (ent && ent.fields) ? each(ent.fields) : []
   for (const f of fields) {
-    if (null == f || null == f.name || false === f.active) {
+    if (null == f || null == f.n || false === f.a) {
       continue
     }
-    spec[f.name] = canonToSpec(f.type, false === f.req)
+    spec[f.n] = canonToSpec(f.t, false === f.r)
   }
 
   return spec

package/src/helpers/getMatchEntries.ts

@@ -1,7 +1,7 @@
 
 function getMatchEntries(step: any): [string, any][] {
-  if (!step?.match) return []
-  return Object.entries(step.match).filter(([k]: any) => !k.endsWith('$'))
+  if (!step?.m) return []
+  return Object.entries(step.m).filter(([k]: any) => !k.endsWith('$'))
 }
 
 

package/src/helpers/modelNames.ts

@@ -4,6 +4,8 @@
 import { each, names } from 'jostraca'
 import { KIT } from '@voxgig/apidef'
 
+import { entityRelationName } from './buildIdNames'
+
 import { prefixLeadingDigit } from './naming'
 
 
@@ -172,7 +174,10 @@ function renameReferences(model: any, renames: Rename[]): void {
     }
     ent.relations.ancestors = ancestors.map((a: any) =>
       Array.isArray(a)
-        ? a.map((n: any) => map.get(n) ?? n)
+        ? a.map((n: string) => {
+          const renamed = map.get(entityRelationName(n))
+          return renamed == null ? n : n.startsWith('$.') ? '$.main.kit.entity.' + renamed : renamed
+        })
         : (map.get(a) ?? a))
   })
 }

package/src/helpers/opShape.ts

@@ -62,10 +62,10 @@ function opActions(op: any): { action: string, path: string }[] {
   const points: any[] = op && op.points ? each(op.points) : []
 
   return points
-    .filter((pt: any) => null != (pt && pt.select && pt.select['$action']))
+    .filter((pt: any) => null != (pt && pt.q && pt.q['$action']))
     .map((pt: any) => ({
-      action: String(pt.select['$action']),
-      path: String(pt.orig || ''),
+      action: String(pt.q['$action']),
+      path: String(pt.o || ''),
     }))
     .sort((a, b) => a.action < b.action ? -1 : a.action > b.action ? 1 : 0)
 }
@@ -93,11 +93,11 @@ function entityPath(entity: any): string {
 
     const points: any[] = op.points ? each(op.points) : []
     const canonical = points.filter((pt: any) =>
-      null == (pt && pt.select && pt.select['$action']))
+      null == (pt && pt.q && pt.q['$action']))
 
     const pick = (0 < canonical.length ? canonical : points)[0]
-    if (null != pick && null != pick.orig && '' !== pick.orig) {
-      return String(pick.orig)
+    if (null != pick && null != pick.o && '' !== pick.o) {
+      return String(pick.o)
     }
   }
 
@@ -109,7 +109,7 @@ function ownPoint(points: any[]): any {
   let best = points[0]
 
   for (const pt of points) {
-    if (null == pt || null == pt.segments || null == best || null == best.segments) {
+    if (null == pt || null == pt.s || null == best || null == best.s) {
       continue
     }
 
@@ -140,7 +140,7 @@ function opParams(op: any): any[] {
   let points: any[] = op && op.points ? each(op.points) : []
 
   const canonical = points.filter((pt: any) =>
-    null == (pt && pt.select && pt.select['$action']))
+    null == (pt && pt.q && pt.q['$action']))
   if (0 < canonical.length) {
     points = canonical
   }
@@ -152,17 +152,17 @@ function opParams(op: any): any[] {
   points.forEach((pt: any, pointIndex: number) => {
     // Path AND query: a path-param-only read misses e.g. GET /result?trace_id=,
     // which has no path param at all but still addresses one record.
-    const pathParams = pt && pt.args && pt.args.params ? each(pt.args.params) : []
-    const queryParams = pt && pt.args && pt.args.query ? each(pt.args.query) : []
+    const pathParams = pt && pt.g && pt.g.params ? each(pt.g.params) : []
+    const queryParams = pt && pt.g && pt.g.query ? each(pt.g.query) : []
     const params = [...pathParams, ...queryParams]
     const requiredHere: Record<string, boolean> = {}
     params.forEach((p: any) => {
-      if (p && null != p.name) {
-        requiredHere[p.name] = false !== p.reqd
-        if (!seen[p.name]) {
-          seen[p.name] = { ...p }
-          requiredOnAll[p.name] = 0 === pointIndex
-          out.push(seen[p.name])
+      if (p && null != p.n) {
+        requiredHere[p.n] = false !== p.r
+        if (!seen[p.n]) {
+          seen[p.n] = { ...p }
+          requiredOnAll[p.n] = 0 === pointIndex
+          out.push(seen[p.n])
         }
       }
     })
@@ -174,10 +174,10 @@ function opParams(op: any): any[] {
   })
 
   out.forEach((p: any) => {
-    p.reqd = true === requiredOnAll[p.name]
+    p.r = true === requiredOnAll[p.n]
   })
 
-  if (1 < points.length && !out.some((p: any) => p.reqd) && !samePath(points)) {
+  if (1 < points.length && !out.some((p: any) => p.r) && !samePath(points)) {
     return opParams({ points: [ownPoint(points)] })
   }
 
@@ -194,12 +194,12 @@ function fieldInOp(field: any, opname: string): boolean {
 function fieldOptional(field: any, opname: string): boolean {
   switch (opname) {
     case 'create':
-      return false === field.req
+      return false === field.r
     case 'update':
       return true
     case 'load':
     case 'remove':
-      return 'id' !== field.name
+      return 'id' !== field.n
     case 'list':
     default:
       return true
@@ -223,30 +223,30 @@ function opRequestShape(ent: any, opname: string):
   const params = opParams(op)
   if (0 < params.length && !isbodyop) {
     const items = params.map((p: any) => ({
-      name: p.name,
-      type: p.type,
-      optional: false === p.reqd,
+      name: p.n,
+      type: p.t,
+      optional: false === p.r,
     }))
     return { items, fromParams: true }
   }
 
   const paramItems = isbodyop ? params.map((p: any) => ({
-    name: p.name,
-    type: p.type,
-    optional: false === p.reqd,
+    name: p.n,
+    type: p.t,
+    optional: false === p.r,
   })) : []
   const paramNames = new Set(paramItems.map((p: any) => p.name))
 
   const fields = (ent.fields ? each(ent.fields) : [])
-    .filter((f: any) => f.active !== false)
+    .filter((f: any) => f.a !== false)
     .filter((f: any) => fieldInOp(f, opname))
 
   const items = paramItems.concat(
     fields
-      .filter((f: any) => !paramNames.has(f.name))
+      .filter((f: any) => !paramNames.has(f.n))
       .map((f: any) => ({
-        name: f.name,
-        type: f.type,
+        name: f.n,
+        type: f.t,
         optional: fieldOptional(f, opname),
       })))
 
@@ -453,7 +453,7 @@ function medianOf(xs: number[]): number {
 }
 
 
-// The id field on the entity's DATA type (its fields[]), or null. DISTINCT from
+// The id field on the entity's DATA type (its fields{}), or null. DISTINCT from
 // entityIdField (the load-MATCH key): an API can model a load match that carries
 // an `id` param while the response entity itself has no `id` field, so `.id`
 // access on a RETURNED record must be guarded on this, not on the match key.
@@ -463,10 +463,10 @@ function entityDataIdField(ent: any): string | null {
   }
   const idName = (ent.id && ent.id.field) || 'id'
   const fields = ent.fields ? each(ent.fields) : []
-  if (fields.some((f: any) => f && f.name === idName)) {
+  if (fields.some((f: any) => f && f.n === idName)) {
     return idName
   }
-  if (fields.some((f: any) => f && f.name === 'id')) {
+  if (fields.some((f: any) => f && f.n === 'id')) {
     return 'id'
   }
   return null

package/src/helpers/pointPath.ts

@@ -12,18 +12,13 @@ type PathSegment = {
 
 
 function pointSegments(point: any): PathSegment[] {
-  const segments = point && point.segments
+  const segments = point && point.s
 
-  if (!Array.isArray(segments) && Array.isArray(point && point.parts)) {
+  if (!Array.isArray(segments) && (Array.isArray(point?.parts) || Array.isArray(point?.segments))) {
     throw new SdkGenError(
-      'model: the point for `' + ((point && point.orig) || '(unknown path)') +
-      '` still describes its path as `parts` (' +
-      JSON.stringify(point.parts) + ') and carries no `segments`. apidef ' +
-      'replaced the braced-string form with the typed segment vector in ' +
-      '8.2.0 (its ADR-003), so this model was generated by an older apidef ' +
-      'and has not been regenerated. Generating from it would build every ' +
-      'URL as the API root. Run `npm run generate` in the project\'s `.sdk` ' +
-      'so apidef rewrites its entity models, then generate again.')
+      'model: the point for `' + (point?.o || point?.orig || '(unknown path)') +
+      '` uses an obsolete path shape. Typed segments belong in `s`. ' +
+      'Run `npm run generate` in the project\'s `.sdk` to regenerate the API model.')
   }
 
   return Array.isArray(segments) ? segments : []

package/src/helpers/resolved.ts

@@ -13,13 +13,8 @@ function resolvedFor(ctx$: any): ResolvedSpec | undefined {
 
 
 
-// A point's live-scenario hint. apidef sets `point.live` from the guide; a
-// model built before it did carries the hint only inside the contract.
 function liveHint(point: any): any {
-  if (null == point) return undefined
-  if (undefined !== point.live) return point.live
-  if (null == point.contract?.json) return undefined
-  try { return JSON.parse(point.contract.json).live } catch { return undefined }
+  return point?.li
 }
 
 
@@ -30,18 +25,12 @@ function hasLiveScenarios(model: any): boolean {
 }
 
 
-// A point's resolved specification facts. Prefers the capability apidef
-// publishes; falls back to the contract for a model built before it, or a
-// generation not driven through a model build.
 function pointFacts(ctx$: any, point: any): any {
-  const resolved = resolvedFor(ctx$)
-  const facts = resolved?.operation(point?.method, point?.orig)
-  if (null != facts) return facts
-  if (null == point?.contract?.json) return {}
-  try { return JSON.parse(point.contract.json) } catch { return {} }
+  return resolvedFor(ctx$)?.operation(point?.m, point?.o) || {}
 }
 
 
+
 export {
   resolvedFor,
   liveHint,

package/src/sdkgen.ts

@@ -57,7 +57,7 @@ import { registerComponent } from './cmp/Registered'
 import { resolvedFor, liveHint, pointFacts, hasLiveScenarios } from './helpers/resolved'
 import type { RegisterOptions } from './cmp/Registered'
 
-import { buildIdNames } from './helpers/buildIdNames'
+import { buildIdNames, entityRelationName, flowSteps } from './helpers/buildIdNames'
 import { getMatchEntries } from './helpers/getMatchEntries'
 import { collectDeps } from './helpers/collectDeps'
 import { guardModelNames } from './helpers/modelNames'
@@ -992,6 +992,8 @@ export {
   SdkGenError,
 
   buildIdNames,
+  entityRelationName,
+  flowSteps,
   getMatchEntries,
   collectDeps,
 

package/src/utility.ts

@@ -263,13 +263,19 @@ function withPointParts(op: any): any {
   each(op, (o: any, opname: string) => {
     out[opname] = null == o || null == o.points ? o : {
       ...o,
-      points: each(o.points).map((pt: any) => {
+      points: each(o.points).filter((pt: any) => false !== pt?.a).map((pt: any) => {
         if (null == pt) return pt
-        // Contracts feed test generation directly from the model. Keeping
-        // them in every runtime entity also retains entire request/response
-        // schemas in clones and debug output, exhausting large SDKs' memory.
-        const { contract, ...runtimePoint } = pt
-        return { ...runtimePoint, parts: pointParts(pt) }
+        const args = Object.fromEntries(Object.entries(pt.g || {}).map(([kind, values]) =>
+          [kind, each(values as any).filter((arg: any) => false !== arg.a).map((arg: any) => ({
+            name: arg.n, orig: arg.or, type: arg.t, kind: arg.k,
+            reqd: arg.r, example: arg.ex,
+          }))]))
+        // Runtime hooks expose descriptive names independently of the model schema.
+        return {
+          active: pt.a, kind: pt.k, method: pt.m, orig: pt.o,
+          segments: pt.s, parts: pointParts(pt), rename: pt.r,
+          transform: pt.t, args, select: pt.q, live: pt.li, graphql: pt.gq,
+        }
       }),
     }
   })
@@ -298,7 +304,10 @@ function configDefinition(model: any, targetname?: string): { def: any, json: st
   const entityStubs: any = {}
   each(entity, (e: any) => {
     entityDefs[e.name] = clean({
-      fields: e.fields,
+      fields: each(e.fields || {}).filter((f: any) => false !== f.a).map((f: any) => ({
+        name: f.n, title: f.h, type: f.t, req: f.r, op: f.op,
+        short: f.sh, readOnly: f.ro, writeOnly: f.wo, deprecated: f.de, format: f.fo,
+      })),
       id: e.id,
       name: e.name,
       op: withPointParts(e.op),