@voxgig/sdkgen 4.22.0 → 4.24.0

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),