@voxgig/apidef 8.13.0 → 8.15.0

package/src/transform/field.ts

@@ -7,7 +7,7 @@ import type { TransformResult, Transform } from '../transform'
 import {
   validator, canonizeField, inferFieldType, normalizeFieldName, envelopeProp,
   canonizeCmpName,
-  scanUntaggedUnion, firstSentence,
+  scanUntaggedUnion, firstSentence, humanTitle,
 } from '../utility'
 
 import { KIT } from '../types'
@@ -42,7 +42,6 @@ const fieldTransform: Transform = async function(
 
   each(kit.entity, (ment: ModelEntity, _entname: string) => {
     const fields = ment.fields
-    const seen: any = {}
 
     for (let opname of opFieldPrecedence) {
       const mop = ment.op[opname]
@@ -53,70 +52,63 @@ const fieldTransform: Transform = async function(
           const opfields = resolveOpFields(ment, mop, mpoint, def)
 
           for (let opfield of opfields) {
-            if (!seen[opfield.name]) {
-              fields.push(opfield)
-              seen[opfield.name] = opfield
+            if (!Object.prototype.hasOwnProperty.call(fields, opfield.n)) {
+              fields[opfield.n] = opfield
             }
             else {
-              mergeField(mop, seen[opfield.name], opfield)
+              mergeField(mop, fields[opfield.n], opfield)
             }
           }
         }
       }
     }
 
-    fields.sort((a: ModelField, b: ModelField) => {
-      return a.name < b.name ? -1 : a.name > b.name ? 1 : 0
-    })
 
     const gent = guide?.entity?.[ment.name]
     const composite = compositeId(ment, gent, def)
 
-    const idField = fields.find((f: ModelField) => 'id' === f.name)
+    const idField = fields.id
 
     if (null != composite.parts && null != idField && !scalarStringField(idField)) {
       const idf: any = idField
       const apiname = String((model as any)?.name || 'api')
       const keep = apiname + '_id'
 
-      if (!fields.some((f: ModelField) => f.name === keep)) {
+      if (!Object.prototype.hasOwnProperty.call(fields, keep)) {
         // A DEEP COPY, because the move is followed by deletions on the
         // original. A spread shares the `op` object, so clearing the stale
         // per-op `type` off `id` cleared it off the preserved field too —
         // the preservation preserved nothing for exactly the key it was
         // added to keep.
-        fields.push(JSON.parse(JSON.stringify({ ...idf, name: keep })) as any)
+        fields[keep] = JSON.parse(JSON.stringify({ ...idf, n: keep }))
 
         const alias = ((ment as any).alias = (ment as any).alias || {})
         alias.field = alias.field || {}
         alias.field[keep] = 'id'
       }
 
-      idf.type = '`$STRING`'
-      // The facts that described the moved type go with it: `format: int64`
+      idf.t = '`$STRING`'
+      // The facts that described the moved type go with it: `fo: int64`
       // beside a string, or a per-op `type` override still saying integer,
       // is a model contradicting itself — and the op override is what a
       // generator reads for that op.
-      delete idf.format
+      delete idf.fo
       for (const opname of Object.keys(idf.op || {})) {
         delete idf.op[opname].type
       }
 
-      fields.sort((a: ModelField, b: ModelField) =>
-        a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
     }
 
     if (null != composite.parts && null == idField) {
       // The FIELD as well as the descriptor, for the reason the branch below
       // documents: a model that declares the descriptor without the field
       // makes the generated type disagree with the generated test.
-      fields.push({
-        name: 'id',
-        type: '`$STRING`',
-        req: false,
-      } as any)
-      fields.sort((a: ModelField, b: ModelField) =>
-        a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+      fields.id = {
+        n: 'id',
+        h: humanTitle('id'),
+        t: '`$STRING`',
+        r: false,
+      } as ModelField
     }
 
     const singleKey = (composite as any).single
@@ -126,30 +118,34 @@ const fieldTransform: Transform = async function(
       // The guide disabled composite; the terminal parameter is the key, and
       // the entity needs the field to carry it for the same reason the
       // composite branch above does.
-      fields.push({
-        name: 'id',
-        type: '`$STRING`',
-        req: false,
-      } as any)
-      fields.sort((a: ModelField, b: ModelField) =>
-        a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+      fields.id = {
+        n: 'id',
+        h: humanTitle('id'),
+        t: '`$STRING`',
+        r: false,
+      } as ModelField
     }
 
     if (idField || null != composite.parts || null != singleKey) {
       ment.id = { name: 'id', field: 'id', ...composite }
     }
     else if (addressedById(ment)) {
-      fields.push({
-        name: 'id',
-        type: '`$STRING`',
-        req: false,
-      } as any)
-      fields.sort((a: ModelField, b: ModelField) =>
-        a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
+      fields.id = {
+        n: 'id',
+        h: humanTitle('id'),
+        t: '`$STRING`',
+        r: false,
+      } as ModelField
 
       ment.id = { name: 'id', field: 'id', ...composite }
     }
 
+    ment.fields = Object.fromEntries(Object.keys(fields).sort().map(n => {
+      const field = fields[n]
+      field.h = humanTitle(field.n)
+      return [n, field]
+    }))
+
     msg += ment.name + ' '
   })
 
@@ -174,7 +170,7 @@ const ID_OPS = ['load', 'update', 'patch', 'remove']
 
 
 function trailingVars(point: any): string[] {
-  const segs = ((point?.segments || []) as any[]).filter((s: any) => null != s)
+  const segs = ((point?.s || []) as any[]).filter((s: any) => null != s)
   const run: string[] = []
 
   for (let i = segs.length - 1; 0 <= i; i--) {
@@ -199,7 +195,7 @@ function identityParams(ment: ModelEntity): string[] {
 
     // Action points are verbs dispatched by `$action`, not addresses.
     for (const pt of (mop.points || [])) {
-      if (null != pt?.select?.['$action']) {
+      if (null != pt?.q?.['$action']) {
         continue
       }
       const run = trailingVars(pt)
@@ -209,7 +205,7 @@ function identityParams(ment: ModelEntity): string[] {
       cands.push({
         run,
         // Segments BEFORE the run: how much parent scope the route needs.
-        scope: ((pt.segments || []).length - run.length),
+        scope: ((pt.s || []).length - run.length),
         own: 'id' === run[run.length - 1] ||
           (ment as any).name + '_id' === run[run.length - 1],
         order: o,
@@ -289,12 +285,12 @@ function responseCandidates(ment: ModelEntity, def: any): any[] {
 
     for (const mpoint of (mop?.points || [])) {
       // An action point's response is not the entity.
-      if (null != mpoint?.select?.['$action']) {
+      if (null != mpoint?.q?.['$action']) {
         continue
       }
 
-      const path = (def?.paths || {})[mpoint?.orig]
-      const method = String(mpoint?.method || '').toLowerCase()
+      const path = (def?.paths || {})[mpoint?.o]
+      const method = String(mpoint?.m || '').toLowerCase()
       const responses = path?.[method]?.responses || {}
 
       for (const code of Object.keys(responses)) {
@@ -384,15 +380,15 @@ function partAliases(ment: ModelEntity, part: string): string[] {
 
   each((ment as any).op, (mop: any) => {
     each(mop?.points, (mpoint: any) => {
-      const rename = mpoint?.rename?.param || {}
+      const rename = mpoint?.r?.param || {}
       for (const orig of Object.keys(rename)) {
         if (String(rename[orig]) === part) {
           names.add(orig)
         }
       }
-      for (const arg of (mpoint?.args?.params || [])) {
-        if (null != arg && arg.name === part && null != arg.orig) {
-          names.add(String(arg.orig))
+      for (const arg of (mpoint?.g?.params || [])) {
+        if (null != arg && arg.n === part && null != arg.or) {
+          names.add(String(arg.or))
         }
       }
     })
@@ -482,7 +478,7 @@ function identityFrom(
 // Is this model field declared as a string? A composite id is the parts
 // joined, so the field that holds it has to be one.
 function scalarStringField(f: any): boolean {
-  return String(f?.type || '').toUpperCase().includes('STRING')
+  return String(f?.t || '').toUpperCase().includes('STRING')
 }
 
 
@@ -552,8 +548,8 @@ function addressedById(ment: ModelEntity): boolean {
   let found = false
   each((ment as any).op, (mop: any) => {
     each(mop?.points, (mpoint: any) => {
-      each(mpoint?.args?.params, (param: any) => {
-        if (param && 'id' === param.name) {
+      each(mpoint?.g?.params, (param: any) => {
+        if (param && 'id' === param.n) {
           found = true
         }
       })
@@ -579,22 +575,23 @@ function resolveOpFields(
     // items -> item, so the SDK read keys the server never sends.
     const name = canonizeField(normalizeFieldName(fieldname))
     const mfield: ModelField = {
-      name,
-      type: inferFieldType(name, validator(fielddef.type)),
-      req: !!fielddef.required,
+      n: name,
+      h: humanTitle(name),
+      t: inferFieldType(name, validator(fielddef.type)),
+      r: !!fielddef.required,
       op: {},
     }
     const fdesc = (fielddef as any).description
     if ('string' === typeof fdesc && '' !== fdesc.trim()) {
       const short = firstSentence(fdesc)
       if ('' !== short) {
-        mfield.short = short
+        mfield.sh = short
       }
     }
 
-    for (const flag of ['readOnly', 'writeOnly', 'deprecated'] as const) {
+    for (const [flag, attr] of [['readOnly', 'ro'], ['writeOnly', 'wo'], ['deprecated', 'de']] as const) {
       if (true === (fielddef as any)[flag]) {
-        mfield[flag] = true
+        mfield[attr] = true
       }
     }
 
@@ -603,7 +600,7 @@ function resolveOpFields(
     // interpreted here. `password` is the one a generator acts on today.
     const ffmt = (fielddef as any).format
     if ('string' === typeof ffmt && '' !== ffmt.trim()) {
-      mfield.format = ffmt.trim()
+      mfield.fo = ffmt.trim()
     }
 
     // Record an untagged union under this field. The field is already typed
@@ -631,7 +628,7 @@ function findGraphqlFieldDefs(
   mpoint: ModelPoint,
   def: any
 ): SchemaDef[] {
-  const typeName = (mpoint.graphql as any)?.entityType$ ??
+  const typeName = (mpoint.gq as any)?.entityType$ ??
     (ment as any).orig$ ?? ''
   const gtype = def.types?.[typeName]
 
@@ -698,18 +695,18 @@ function findFieldDefs(
   mpoint: ModelPoint,
   def: any
 ): SchemaDef[] {
-  if ('graphql' === mpoint.kind) {
+  if ('graphql' === mpoint.k) {
     return findGraphqlFieldDefs(ment, mpoint, def)
   }
 
   // A verb, rather than an address: see the call site in the transform.
-  const isAction = null != (mpoint as any)?.select?.['$action']
+  const isAction = null != (mpoint as any)?.q?.['$action']
 
   const fielddefs: SchemaDef[] = []
 
-  const pathdef = def.paths[mpoint.orig]
+  const pathdef = def.paths[mpoint.o]
 
-  const method = mpoint.method.toLowerCase()
+  const method = mpoint.m.toLowerCase()
   const opdef: any = (pathdef as any)?.[method]
 
   if (opdef) {
@@ -912,18 +909,18 @@ function mergeField(
   existingField: ModelField,
   newField: ModelField
 ) {
-  if (newField.req !== existingField.req) {
+  if (newField.r !== existingField.r) {
     existingField.op[mop.name] = {
-      req: newField.req,
-      type: newField.type,
+      req: newField.r,
+      type: newField.t,
     }
   }
 
-  if (null == existingField.short && null != newField.short) {
-    existingField.short = newField.short
+  if (null == existingField.sh && null != newField.sh) {
+    existingField.sh = newField.sh
   }
 
-  for (const flag of ['readOnly', 'writeOnly', 'deprecated', 'format'] as const) {
+  for (const flag of ['ro', 'wo', 'de', 'fo'] as const) {
     if (null == existingField[flag] && null != newField[flag]) {
       (existingField as any)[flag] = newField[flag]
     }

package/src/transform/flowstep.ts

@@ -12,19 +12,19 @@ import {
 
 
 function isEntityIdParam(point: any, param: any, opname?: string): boolean {
-  if ('id' === param?.name) return true
-  const renameMap = point?.rename?.param
-  if (renameMap && param?.name) {
-    const camel = lcf(camelify(param.name))
+  if ('id' === param?.n) return true
+  const renameMap = point?.r?.param
+  if (renameMap && param?.n) {
+    const camel = lcf(camelify(param.n))
     if ('id' === renameMap[camel]) return true
   }
   if ('update' === opname || 'load' === opname || 'remove' === opname) {
-    const segments: any[] = point?.segments || []
+    const segments: any[] = point?.s || []
     let last: string | null = null
     for (const s of segments) {
       if (null != s?.var) last = s.var
     }
-    if (last && last === param?.name) return true
+    if (last && last === param?.n) return true
   }
   return false
 }
@@ -75,7 +75,7 @@ const flowstepTransform: Transform = async function(
       {
         input: {
           ref: ref01,
-          textfield: firsttf?.name,
+          textfield: firsttf?.n,
           suffix: '_up0',
           srcdatavar: ref01 + '_data'
         },
@@ -126,12 +126,12 @@ type MakeFlowStep =
 
 function newFlowStep(opname: OpName, args: Record<string, any>): ModelEntityFlowStep {
   return {
-    op: opname,
-    input: args.input ?? {},
-    match: args.match ?? {},
-    data: args.data ?? {},
-    spec: args.spec ?? [],
-    valid: args.valid ?? [],
+    o: opname,
+    i: args.input ?? {},
+    m: args.match ?? {},
+    d: args.data ?? {},
+    s: args.spec ?? [],
+    v: args.valid ?? [],
   }
 }
 
@@ -142,7 +142,7 @@ function newFlowStep(opname: OpName, args: Record<string, any>): ModelEntityFlow
 // rename-to-id is recorded — the literal `id` then represents the entity's
 // own id and createStep should skip it.
 function originalSnakeNameOfRenamedId(point: any): string | null {
-  const renameMap = point?.rename?.param || {}
+  const renameMap = point?.r?.param || {}
   for (const [src, dst] of Object.entries(renameMap)) {
     if ('id' === dst) {
       const srcStr = String(src)
@@ -165,17 +165,17 @@ const createStep: MakeFlowStep = (
     const point = getelem(opmap.create.points, -1)
     const step = newFlowStep('create', args)
 
-    each(point.args.params, (param: any) => {
-      if ('id' === param.name) {
+    each(point.g.params, (param: any) => {
+      if ('id' === param.n) {
         const origName = originalSnakeNameOfRenamedId(point)
         if (origName) {
-          step.match[origName] = args.input?.[origName] ?? origName.replace(/_id/, '') + '01'
+          step.m[origName] = args.input?.[origName] ?? origName.replace(/_id/, '') + '01'
         }
         // If there's no rename-from, this is genuinely the entity's id — skip
         // (the create call generates it).
         return
       }
-      step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      step.m[param.n] = args.input?.[param.n] ?? param.n.replace(/_id/, '') + '01'
     })
 
     seedRelatedOpParams(opmap, point, step)
@@ -191,14 +191,14 @@ function seedRelatedOpParams(opmap: any, createPoint: any, step: ModelEntityFlow
     const op = opmap[opname]
     if (!op?.points) continue
     for (const point of op.points) {
-      const params: any[] = point?.args?.params || []
+      const params: any[] = point?.g?.params || []
       for (const param of params) {
-        if (!param?.name) continue
+        if (!param?.n) continue
         if (isEntityIdParam(point, param, opname as any)) continue
-        if (step.match[param.name] !== undefined) continue
-        if ('id' === param.name) continue
-        step.match[param.name] =
-          param.name.replace(/_id/, '') + '01'
+        if (step.m[param.n] !== undefined) continue
+        if ('id' === param.n) continue
+        step.m[param.n] =
+          param.n.replace(/_id/, '') + '01'
       }
     }
   }
@@ -216,15 +216,15 @@ const listStep: MakeFlowStep = (
     const point = getelem(opmap.list.points, -1)
     const step = newFlowStep('list', args)
 
-    each(point.args.params, (param: any) => {
-      if ('id' === param.name) {
+    each(point.g.params, (param: any) => {
+      if ('id' === param.n) {
         const origName = originalSnakeNameOfRenamedId(point)
         if (origName) {
-          step.match[origName] = args.input?.[origName] ?? origName.replace(/_id/, '') + '01'
+          step.m[origName] = args.input?.[origName] ?? origName.replace(/_id/, '') + '01'
         }
         return
       }
-      step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      step.m[param.n] = args.input?.[param.n] ?? param.n.replace(/_id/, '') + '01'
     })
 
     flow.step.push(step)
@@ -243,13 +243,13 @@ const updateStep: MakeFlowStep = (
     const point = getelem(opmap.update.points, -1)
     const step = newFlowStep('update', args)
 
-    each(point.args.params, (param: any) => {
+    each(point.g.params, (param: any) => {
       if (isEntityIdParam(point, param, 'update')) {
         // Entity's own id — supplied at test time via the loaded/created
         // entity's id field, not as a separate body parameter. Skip.
         return
       }
-      step.data[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      step.d[param.n] = args.input?.[param.n] ?? param.n.replace(/_id/, '') + '01'
     })
 
     flow.step.push(step)
@@ -268,12 +268,12 @@ const loadStep: MakeFlowStep = (
     const point = getelem(opmap.load.points, -1)
     const step = newFlowStep('load', args)
 
-    each(point.args.params, (param: any) => {
+    each(point.g.params, (param: any) => {
       if (isEntityIdParam(point, param, 'load')) {
-        step.match.id = args.input?.id ?? ent.name + '01'
+        step.m.id = args.input?.id ?? ent.name + '01'
       }
       else {
-        step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+        step.m[param.n] = args.input?.[param.n] ?? param.n.replace(/_id/, '') + '01'
       }
     })
 
@@ -297,12 +297,12 @@ const removeStep: MakeFlowStep = (
     const point = getelem(opmap.remove.points, -1)
     const step = newFlowStep('remove', args)
 
-    each(point.args.params, (param: any) => {
+    each(point.g.params, (param: any) => {
       if (isEntityIdParam(point, param, 'remove')) {
-        step.match.id = args.input?.id ?? ent.name + '01'
+        step.m.id = args.input?.id ?? ent.name + '01'
       }
       else {
-        step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+        step.m[param.n] = args.input?.[param.n] ?? param.n.replace(/_id/, '') + '01'
       }
     })
 
@@ -314,14 +314,14 @@ const removeStep: MakeFlowStep = (
 function firstTextField(ent: ModelEntity, op?: ModelOp) {
   const paramNames: Record<string, boolean> = {}
   each((op as any)?.points).forEach((pt: any) => {
-    each(pt?.args?.params).forEach((p: any) => {
-      if (p && null != p.name) {
-        paramNames[p.name] = true
+    each(pt?.g?.params).forEach((p: any) => {
+      if (p && null != p.n) {
+        paramNames[p.n] = true
       }
     })
   })
 
-  const fields = each(ent.fields)
+  const fields = Object.keys(ent.fields).sort().map(n => ent.fields[n])
   for (let fI = 0; fI < fields.length; fI++) {
     const field = fields[fI]
     // NOT A readOnly FIELD. The flow writes this one and then asserts the
@@ -329,8 +329,8 @@ function firstTextField(ent: ModelEntity, op?: ModelOp) {
     // was chosen for. Fields are sorted by name, so which field this lands on
     // is alphabetical accident: solar's planet, once its spec declared the
     // server-assigned `forbidReason`, marked that instead of `kind`.
-    if ('`$STRING`' === field.type && 'id' !== field.name &&
-      true !== field.readOnly && true !== paramNames[field.name]) {
+    if ('`$STRING`' === field.t && 'id' !== field.n &&
+      true !== field.ro && true !== paramNames[field.n]) {
       return field
     }
   }

package/src/transform/graphql.ts

@@ -177,7 +177,7 @@ const graphqlTransform: Transform = async function(
 
     each(ment.op, (mop: ModelOp, opname: OpName) => {
       each(mop.points, (mpoint: ModelPoint) => {
-        const rootfield = mpoint.orig
+        const rootfield = mpoint.o
 
         const gfield: GuidePath | undefined = (gent as any)?.field?.[rootfield]
         const optype = (gfield?.op?.[opname] as any)?.optype ?? 'query'
@@ -231,11 +231,11 @@ const graphqlTransform: Transform = async function(
         const docname = pascal(entname) + pascal(opname) +
           (null != actionName ? pascal(actionName) : '')
 
-        mpoint.kind = 'graphql'
-        mpoint.method = 'POST'
-        mpoint.segments = []
+        mpoint.k = 'graphql'
+        mpoint.m = 'POST'
+        mpoint.s = []
 
-        mpoint.graphql = {
+        mpoint.gq = {
           optype: optype as 'query' | 'mutation',
           field: rootfield,
           doc: renderDoc(docname, optype, rootfield, vars, selection,
@@ -246,10 +246,10 @@ const graphqlTransform: Transform = async function(
         // Carried for the field transform, which derives entity fields from
         // the same object type. The `$` suffix makes cleanTransform strip it
         // from the emitted model — it is pipeline state, not wire data.
-        ;(mpoint.graphql as any).entityType$ = entityType
+        ;(mpoint.gq as any).entityType$ = entityType
 
         if ('connection' === ret.kind) {
-          mpoint.graphql.page = {
+          mpoint.gq.page = {
             style: 'relay',
             nodes: ret.nodes ?? 'nodes',
             cursor: 'pageInfo.endCursor',
@@ -257,7 +257,7 @@ const graphqlTransform: Transform = async function(
           }
         }
 
-        mpoint.transform.res = '`' + respath + '`'
+        mpoint.t.res = '`' + respath + '`'
       })
     })
 

package/src/transform/operation.ts

@@ -184,19 +184,19 @@ function resolveOp(opname: OpName, gent: GuideEntity): undefined | ModelOp {
         const segments = p.segments
 
         const mpoint: ModelPoint = {
-          orig: p.orig,
-          segments,
-          rename: p.rename,
-          method: p.method,
-          args: {},
-          transform: { ...((p as any).op?.transform ?? {}) },
-          select: {
+          o: p.orig,
+          s: segments,
+          r: p.rename,
+          m: p.method,
+          g: {},
+          t: { ...((p as any).op?.transform ?? {}) },
+          q: {
             exist: []
           }
         }
 
-        mpoint.transform.req = mpoint.transform.req ?? '`reqdata`'
-        mpoint.transform.res = mpoint.transform.res ?? '`body`'
+        mpoint.t.req = mpoint.t.req ?? '`reqdata`'
+        mpoint.t.res = mpoint.t.res ?? '`body`'
 
         return mpoint
       })