@voxgig/apidef 2.4.1 → 3.1.0

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.update.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.update.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,
+}