@voxgig/apidef 3.0.2 → 3.1.1

package/src/resolver.ts

@@ -3,6 +3,8 @@
 
 import Path from 'node:path'
 
+import { relativizePath } from './utility'
+
 
 async function resolveElements(
   ctx: any,
@@ -77,7 +79,7 @@ async function resolveElement(
   }
   catch (e: any) {
     const err = new Error('Custom element not found: ' +
-      customtpath + ': ' + e.message)
+      relativizePath(customtpath) + ': ' + e.message)
     log.error({ what: 'element', element: target + ': ' + en, fail: 'require', err })
     throw err
   }

package/src/transform/args.ts

@@ -27,7 +27,7 @@ import type {
 
 
 
-const argsTransform = async function(
+const argsTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel, def } = ctx
@@ -49,6 +49,7 @@ const argsTransform = async function(
 
         resolveArgs(ment, mop, malt, argdefs)
       })
+
     })
 
     msg += ment.name + ' '
@@ -68,11 +69,15 @@ const ARG_KIND: Record<string, ModelArg["kind"]> = {
 
 function resolveArgs(ment: ModelEntity, mop: ModelOp, malt: ModelAlt, argdefs: ParameterDef[]) {
   each(argdefs, (argdef: ParameterDef) => {
+    const orig = depluralize(snakify(argdef.name))
+    const kind = ARG_KIND[argdef.in] ?? 'query'
+    const name = malt.rename[kind]?.[orig] ?? orig
     const marg: ModelArg = {
-      name: depluralize(snakify(argdef.name)),
+      name,
+      orig,
       type: validator(argdef.schema?.type),
-      kind: ARG_KIND[argdef.in] ?? 'query',
-      req: !!argdef.required
+      kind,
+      reqd: !!argdef.required
     }
 
     if (argdef.nullable) {
@@ -81,17 +86,8 @@ function resolveArgs(ment: ModelEntity, mop: ModelOp, malt: ModelAlt, argdefs: P
 
     // insert sorted by name
     let kindargs = (malt.args[marg.kind] = malt.args[marg.kind] ?? [])
-
-    let kalen = kindargs.length
-    for (let ka, i = 0; i <= kalen; i++) {
-      ka = kindargs[i]
-      if (ka && ka.name > marg.name) {
-        kindargs = [...kindargs.slice(0, i), marg, ...kindargs.slice(i + 1)]
-      }
-      else {
-        kindargs.push(marg)
-      }
-    }
+    kindargs.push(marg)
+    kindargs.sort((a: ModelArg, b: ModelArg) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)
   })
 }
 

package/src/transform/clean.ts

@@ -1,19 +1,18 @@
 
-import type { TransformResult } from '../transform'
+import type { TransformResult, Transform } from '../transform'
 
 import { walk, isempty, isnode, ismap, islist } from '@voxgig/struct'
 
-import { formatJSONIC } from '../utility'
 
-
-const cleanTransform = async function(
+const cleanTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel } = ctx
 
   let cur: any[] = []
 
-  // Remove empty nodes and undefined values
+  // Remove empty nodes and undefined values. This avoids spurious content in model.
+  // NOTE: including ancestors if thus also empty!
   walk(
     apimodel,
     (k: any, v: any, _p: any, ancestors: any) => {

package/src/transform/entity.ts

@@ -4,18 +4,16 @@ import { each } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { formatJSONIC } from '../utility'
-
 import { KIT } from '../types'
 
 import type { KitModel } from '../types'
 
 import type {
   GuideEntity,
-} from './top'
+  GuidePath,
+} from '../types'
 
 import type {
-  GuidePath,
   PathDesc,
 } from '../desc'
 
@@ -25,8 +23,7 @@ import type {
 
 
 
-
-const entityTransform = async function(
+const entityTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel, guide } = ctx
@@ -85,7 +82,7 @@ function resolvePathList(guideEntity: GuideEntity, def: { paths: Record<string,
     paths$.push(pathdesc)
   })
 
-  guideEntity.paths$ = paths$
+    ; (guideEntity as any).paths$ = paths$
 
   return paths$
 }

package/src/transform/field.ts

@@ -2,47 +2,31 @@
 
 import { each, getx } from 'jostraca'
 
-import { getelem } from '@voxgig/struct'
-
 import type { TransformResult, Transform } from '../transform'
 
-import { fixName } from '../transform'
-
-import { formatJSONIC, validator, canonize } from '../utility'
+import { validator, canonize } from '../utility'
 
 import { KIT } from '../types'
 
-import type { KitModel } from '../types'
+import type {
+  KitModel,
+} from '../types'
 
 import type {
-  PathDef,
-  ParameterDef,
-  MethodDef,
   SchemaDef,
 } from '../def'
 
-import type {
-  GuideEntity,
-} from './top'
-
-import type {
-  GuideOp,
-  PathDesc,
-} from '../desc'
-
 import type {
   OpName,
-  ModelOpMap,
   ModelOp,
   ModelEntity,
   ModelAlt,
-  ModelArg,
   ModelField,
 } from '../model'
 
 
 
-const fieldTransform = async function(
+const fieldTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel, def } = ctx
@@ -52,9 +36,7 @@ const fieldTransform = async function(
 
   const opFieldPrecedence: OpName[] = ['load', 'create', 'update', 'patch', 'list']
 
-  each(kit.entity, (ment: ModelEntity, entname: string) => {
-    const fielddefs: SchemaDef[] = []
-
+  each(kit.entity, (ment: ModelEntity, _entname: string) => {
     const fields = ment.fields
     const seen: any = {}
 
@@ -116,7 +98,7 @@ function resolveOpFields(
 
 
 function findFieldDefs(
-  ment: ModelEntity,
+  _ment: ModelEntity,
   mop: ModelOp,
   malt: ModelAlt,
   def: any

package/src/transform/flow.ts

@@ -0,0 +1,59 @@
+
+
+import { each } from 'jostraca'
+
+import type { TransformResult, Transform } from '../transform'
+
+import {
+  nom,
+} from '../utility'
+
+import { KIT } from '../types'
+
+import type { KitModel } from '../types'
+
+import type {
+  GuideEntity,
+} from '../types'
+
+import type {
+  ModelEntity,
+  ModelEntityFlow,
+} from '../model'
+
+
+
+
+const flowTransform: Transform = async function(
+  ctx: any,
+): Promise<TransformResult> {
+  const { apimodel, guide } = ctx
+  const kit: KitModel = apimodel.main[KIT]
+
+  let msg = ''
+
+  each(guide.entity, (guideEntity: GuideEntity, entname: string) => {
+    ctx.log.debug({ point: 'guide-flow', note: entname })
+
+    const modelent: ModelEntity = kit.entity[entname]
+
+    const basicflow: ModelEntityFlow = {
+      name: 'Basic' + nom(modelent, 'Name') + 'Flow',
+      entity: entname,
+      kind: 'basic',
+      step: [],
+    }
+
+    kit.flow[basicflow.name] = basicflow
+
+    msg += basicflow.name + ' '
+  })
+
+  return { ok: true, msg }
+}
+
+
+
+export {
+  flowTransform,
+}

package/src/transform/flowstep.ts

@@ -0,0 +1,242 @@
+
+
+import { each } from 'jostraca'
+
+import type { TransformResult, Transform } from '../transform'
+
+import { getelem } from '@voxgig/struct'
+
+import {
+  nom,
+} from '../utility'
+
+import { KIT } from '../types'
+
+import type { KitModel } from '../types'
+
+import type {
+  OpName,
+  GuideEntity,
+} from '../types'
+
+import type {
+  ModelEntity,
+  ModelEntityFlow,
+  ModelEntityFlowStep,
+  ModelOp,
+} from '../model'
+
+
+
+
+const flowstepTransform: Transform = async function(
+  ctx: any,
+): Promise<TransformResult> {
+  const { apimodel, guide } = ctx
+  const kit: KitModel = apimodel.main[KIT]
+
+  let msg = ''
+
+  each(kit.flow, (flow: ModelEntityFlow, flowname: string) => {
+    ctx.log.debug({ point: 'flowstep', note: flowname })
+
+    const ent: ModelEntity = kit.entity[flow.entity]
+    const opmap = ent.op
+
+    // TODO: spec parameter passed into each step func, used semantically by generator
+    // validation: part of spec, semantic name and params, up to generator how to use it
+    const ref01 = ent.name + '_ref01'
+
+    createStep(opmap, flow, ent, { input: { ref: ref01 } })
+
+    listStep(opmap, flow, ent,
+      { valid: [{ apply: 'ItemExists', def: { ref: ref01 } }] })
+
+    const mark01 = 'Mark01-' + ref01
+    const firsttf = firstTextField(ent)
+    updateStep(opmap, flow, ent,
+      {
+        input: {
+          ref: ref01,
+          textfield: firsttf?.name,
+          suffix: '_up0',
+          srcdatavar: ref01 + '_data'
+        },
+        spec: [{
+          apply: 'TextFieldMark',
+          def: { mark: mark01 }
+        }]
+      })
+
+    loadStep(opmap, flow, ent,
+      {
+        input: {
+          ref: ref01,
+          suffix: '_dt0',
+          srcdatavar: ref01 + '_data'
+        },
+        valid: [{
+          apply: 'TextFieldMark',
+          def: { mark: mark01 }
+        }]
+      })
+
+    removeStep(opmap, flow, ent, {
+      input: { ref: ref01, suffix: '_rm0' }
+    })
+
+    if (null != opmap.remove) {
+      listStep(opmap, flow, ent, {
+        input: { suffix: '_rt0' },
+        valid: [{ apply: 'ItemNotExists', def: { ref: ref01 } }]
+      })
+    }
+
+    msg += flowname + ' '
+  })
+
+  return { ok: true, msg }
+}
+
+
+type MakeFlowStep =
+  (opmap: any, flow: ModelEntityFlow, ent: ModelEntity, args: Record<string, any>) => void
+
+
+
+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 ?? [],
+  }
+}
+
+
+const createStep: MakeFlowStep = (
+  opmap: any,
+  flow: ModelEntityFlow,
+  ent: ModelEntity,
+  args: Record<string, any>
+) => {
+  if (null != opmap.update) {
+    // Use last alt as most generic
+    const alt = getelem(opmap.update.alts, -1)
+    const step = newFlowStep('create', args)
+
+    flow.step.push(step)
+  }
+}
+
+
+const listStep: MakeFlowStep = (
+  opmap: any,
+  flow: ModelEntityFlow,
+  ent: ModelEntity,
+  args: Record<string, any>
+) => {
+  if (null != opmap.list) {
+    // Use last alt as most generic
+    const alt = getelem(opmap.list.alts, -1)
+    const step = newFlowStep('list', args)
+
+    each(alt.args.param, (param: any) => {
+      step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+    })
+
+    flow.step.push(step)
+  }
+}
+
+
+const updateStep: MakeFlowStep = (
+  opmap: any,
+  flow: ModelEntityFlow,
+  ent: ModelEntity,
+  args: Record<string, any>
+) => {
+  if (null != opmap.update) {
+    // Use last alt as most generic
+    const alt = getelem(opmap.update.alts, -1)
+    const step = newFlowStep('update', args)
+
+    each(alt.args.param, (param: any) => {
+      if ('id' === param.name) {
+        step.data.id = args.input?.id ?? ent.name + '01'
+      }
+      else {
+        step.data[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      }
+    })
+
+    flow.step.push(step)
+  }
+}
+
+
+const loadStep: MakeFlowStep = (
+  opmap: any,
+  flow: ModelEntityFlow,
+  ent: ModelEntity,
+  args: Record<string, any>
+) => {
+  if (null != opmap.load) {
+    // Use last alt as most generic
+    const alt = getelem(opmap.load.alts, -1)
+    const step = newFlowStep('load', args)
+
+    each(alt.args.param, (param: any) => {
+      if ('id' === param.name) {
+        step.match.id = args.input?.id ?? ent.name + '01'
+      }
+      else {
+        step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      }
+    })
+
+    flow.step.push(step)
+  }
+}
+
+
+const removeStep: MakeFlowStep = (
+  opmap: any,
+  flow: ModelEntityFlow,
+  ent: ModelEntity,
+  args: Record<string, any>
+) => {
+  if (null != opmap.remove) {
+    // Use last alt as most generic
+    const alt = getelem(opmap.remove.alts, -1)
+    const step = newFlowStep('remove', args)
+
+    each(alt.args.param, (param: any) => {
+      if ('id' === param.name) {
+        step.match.id = args.input?.id ?? ent.name + '01'
+      }
+      else {
+        step.match[param.name] = args.input?.[param.name] ?? param.name.replace(/_id/, '') + '01'
+      }
+    })
+
+    flow.step.push(step)
+  }
+}
+
+
+function firstTextField(ent: ModelEntity) {
+  const fields = each(ent.fields)
+  for (let fI = 0; fI < fields.length; fI++) {
+    const field = fields[fI]
+    if ('`$STRING`' === field.type && 'id' !== field.name) {
+      return field
+    }
+  }
+}
+
+export {
+  flowstepTransform,
+}

package/src/transform/operation.ts

@@ -1,25 +1,17 @@
 
 
-import { each, snakify } from 'jostraca'
-
-import { getelem, isempty } from '@voxgig/struct'
+import { each } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { fixName } from '../transform'
-
-import { formatJSONIC } from '../utility'
-
-import { KIT } from '../types'
-
-import type { KitModel } from '../types'
 
-import type {
+import {
+  KIT,
   GuideEntity,
-} from './top'
+  GuidePathOp,
+} from '../types'
 
 import type {
-  GuideOp,
   PathDesc,
 } from '../desc'
 
@@ -32,7 +24,7 @@ import type {
 
 
 
-const operationTransform = async function(
+const operationTransform: Transform = async function(
   ctx: any,
 ): Promise<TransformResult> {
   const { apimodel, guide } = ctx
@@ -40,7 +32,6 @@ const operationTransform = async function(
 
   let msg = 'operation '
 
-
   each(guide.entity, (gent: GuideEntity, entname: string) => {
     collectOps(gent)
 
@@ -49,7 +40,7 @@ const operationTransform = async function(
       list: undefined,
       create: undefined,
       update: undefined,
-      delete: undefined,
+      remove: undefined,
       patch: undefined,
     }
 
@@ -57,7 +48,7 @@ const operationTransform = async function(
     resolveList(opm, gent)
     resolveCreate(opm, gent)
     resolveUpdate(opm, gent)
-    resolveDelete(opm, gent)
+    resolveRemove(opm, gent)
     resolvePatch(opm, gent)
 
     kit.entity[entname].op = opm
@@ -70,21 +61,21 @@ const operationTransform = async function(
 
 
 function collectOps(gent: GuideEntity) {
-  gent.opm$ = gent.opm$ ?? {}
-  each(gent.paths$, (pathdesc: PathDesc) => {
-    each(pathdesc.op, (gop: GuideOp, opname: OpName) => {
-      gent.opm$[opname] = gent.opm$[opname] ?? { paths: [] }
+  ; (gent as any).opm$ = (gent as any).opm$ ?? {}
+  each((gent as any).paths$, (pathdesc: PathDesc) => {
+    each(pathdesc.op, (gop: GuidePathOp, opname: OpName) => {
+      ; (gent as any).opm$[opname] = (gent as any).opm$[opname] ?? { paths: [] }
 
       const oppathdesc: PathDesc = {
         orig: pathdesc.orig,
         parts: pathdesc.parts,
         rename: pathdesc.rename,
-        method: gop.method,
-        op: pathdesc.op,
+        method: gop.method as any,
+        op: gop as any,
         def: pathdesc.def,
       }
 
-      gent.opm$[opname].paths.push(oppathdesc)
+        ; (gent as any).opm$[opname].paths.push(oppathdesc)
     })
   })
 }
@@ -117,8 +108,8 @@ function resolveUpdate(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp
 }
 
 
-function resolveDelete(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
-  const opdesc = opm.delete = resolveOp('delete', gent)
+function resolveRemove(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.remove = resolveOp('remove', gent)
   return opdesc
 }
 
@@ -141,23 +132,28 @@ function resolvePatch(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
 
 function resolveOp(opname: OpName, gent: GuideEntity): undefined | ModelOp {
   let mop: undefined | ModelOp = undefined
-  let opdesc = gent.opm$[opname]
+  let opdesc = (gent as any).opm$[opname]
   if (opdesc) {
-    // console.dir(opdesc, { depth: null })
-
     mop = {
       name: opname,
-      alts: opdesc.paths.map(p => {
+      alts: opdesc.paths.map((p: PathDesc) => {
         const parts = applyRename(p)
 
         const malt: ModelAlt = {
           orig: p.orig,
           parts,
+          rename: p.rename,
           method: p.method,
           args: {},
-          select: {}
+          transform: opdesc.transform ?? {},
+          select: {
+            exist: []
+          }
         }
 
+        malt.transform.req = malt.transform.req ?? '`reqdata`'
+        malt.transform.res = malt.transform.res ?? '`body`'
+
         return malt
       })
     }