@voxgig/apidef 2.0.0 → 2.0.2

package/src/builder/flow/flowHeuristic01.ts

@@ -24,7 +24,7 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
   const apiEntity = apimodel.main.api.entity[entity.name]
 
   const flow: any = {
-    name: 'Basic' + apiEntity.Name
+    name: 'Basic' + apiEntity.Name + 'Flow'
   }
 
   const refs = [
@@ -36,18 +36,21 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
   const idmap = refs.reduce((a: any, ref) => (a[ref] = ref.toUpperCase(), a), {})
 
   flow.model = ({
-    name: flow.Name,
+    name: flow.name,
+    active: true,
     param: {
-      [`${model.NAME}_TEST_${apiEntity.NAME}_ENTID`]: idmap
+      [`${model.NAME}_TEST_${apiEntity.NAME}_ENTID`]: idmap,
+      [`${model.NAME}_TEST_LIVE`]: "FALSE",
+      [`${model.NAME}_TEST_EXPLAIN`]: "FALSE",
     },
-    test: { entity: { [apiEntity.Name]: {} } },
+    test: { entity: { [apiEntity.name]: {} } },
     step: []
   } as any)
 
   names(flow, flow.name)
 
 
-  const data = flow.model.test.entity[apiEntity.Name]
+  const data = flow.model.test.entity[apiEntity.name]
 
   refs.map((ref, i) => {
     const id = idmap[ref]
@@ -73,7 +76,34 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
   let num = 0
   let name
 
+  const am: any = {}
+
   if (apiEntity.op.load) {
+
+    // Get additional required match properties
+    each(apiEntity.op.load.param, (param: any) => {
+      if (param.required) {
+        let ancestorName = param.name
+        let ancestorEntity = apimodel.main.api.entity[ancestorName]
+
+        if (null == ancestorEntity) {
+          ancestorName = ancestorName.replace('_id', '')
+          ancestorEntity = apimodel.main.api.entity[ancestorName]
+        }
+
+        if (ancestorEntity && ancestorName !== apiEntity.name) {
+          flow.model.param[`${model.NAME}_TEST_${ancestorEntity.NAME}_ENTID`] = {
+            [ancestorEntity.name + '01']: ancestorEntity.NAME + '01'
+          }
+          am[param.name] =
+            `\`dm$=p.${model.NAME}_TEST_${ancestorEntity.NAME}_ENTID.${ancestorEntity.name}01\``
+
+          data[`${apiEntity.NAME}01`][param.name] = ancestorEntity.NAME + '01'
+        }
+      }
+    })
+
+
     name = `load_${apiEntity.name}${num}`
     steps.push({
       name,
@@ -81,11 +111,13 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
       entity: `${apiEntity.name}`,
       action: 'load',
       match: {
-        id: `\`dm$=p.${model.NAME}_TEST_${apiEntity.NAME}_ENTID.${apiEntity.name}01\``
+        id: `\`dm$=p.${model.NAME}_TEST_${apiEntity.NAME}_ENTID.${apiEntity.name}01\``,
+        ...am,
       },
       valid: {
         '`$OPEN`': true,
-        id: `\`dm$=s.${name}.match.id\``
+        id: `\`dm$=s.${name}.match.id\``,
+        ...am,
       }
     })
   }
@@ -105,6 +137,7 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
       valid: {
         '`$OPEN`': true,
         id: `\`dm$=s.${loadref}.match.id\``,
+        ...am,
         ...valid
       }
     })
@@ -118,11 +151,13 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
       entity: `${apiEntity.name}`,
       action: 'load',
       match: {
-        id: `\`dm$=p.${model.NAME}_TEST_${apiEntity.NAME}_ENTID.${apiEntity.name}01\``
+        id: `\`dm$=p.${model.NAME}_TEST_${apiEntity.NAME}_ENTID.${apiEntity.name}01\``,
+        ...am,
       },
       valid: {
         '`$OPEN`': true,
         id: `\`dm$=s.${loadref}.match.id\``,
+        ...am,
         ...valid
       }
     })
@@ -136,7 +171,7 @@ function resolveBasicEntityFlow(ctx: any, entity: any) {
 
 function makeUpdateData(name: string, apiEntity: any, flow: any, id: string) {
   const ud: any = {}
-  const data = flow.model.test.entity[apiEntity.Name]
+  const data = flow.model.test.entity[apiEntity.name]
 
   const dataFields = each(apiEntity.field).filter(f => 'id' !== f.name && !f.name.includes('_id'))
   const stringFields = each(dataFields).filter(f => 'string' === f.type)

package/src/builder/flow.ts

@@ -21,6 +21,7 @@ async function makeFlowBuilder(ctx: any) {
     throw new Error('Unknown guide strategy: ' + ctx.opts.strategy)
   }
 
+
   return function flowBuilder() {
 
     Folder({ name: 'flow' }, () => {
@@ -32,13 +33,13 @@ async function makeFlowBuilder(ctx: any) {
         let flowfile =
           Path.join(ctx.opts.folder, 'flow',
             (null == ctx.opts.outprefix ? '' : ctx.opts.outprefix) +
-            flow.Name + 'Flow.jsonic')
+            flow.Name + '.jsonic')
 
         let flowModelSrc = formatJsonSrc(JSON.stringify(flow.model, null, 2))
 
-        let flowsrc = `# ${flow.Name}Flow
+        let flowsrc = `# ${flow.Name}
 
-main: sdk: flow: ${flow.Name}Flow:
+main: sdk: flow: ${flow.Name}:
 ` + flowModelSrc
 
         barrel.push(`@"${Path.basename(flowfile)}"`)

package/src/guide/heuristic01.ts

@@ -3,6 +3,21 @@
 import { each, snakify, names } from 'jostraca'
 
 
+import { depluralize } from '../utility'
+
+
+type EntityDesc = {
+  name: string
+  origname: string
+  plural: string
+  path: Record<string, EntityPathDesc>
+  alias: Record<string, string>
+}
+
+
+type EntityPathDesc = {
+  op: Record<string, any>
+}
 
 async function heuristic01(ctx: any): Promise<Record<string, any>> {
   let guide = ctx.model.main.api.guide
@@ -35,29 +50,14 @@ function resolveEntityDescs(ctx: any) {
   const entityDescs: Record<string, any> = {}
   const paths = ctx.def.paths
 
-  each(paths, (pathdef, pathname) => {
-    // look for rightmmost /entname/{entid}
-    const m = pathname.match(/\/([a-zA-Z0-1_-]+)\/\{([a-zA-Z0-1_-]+)\}$/)
-    if (m) {
-      let origentname = snakify(m[1])
-      let entname = depluralize(origentname)
-
-      let entdesc = (entityDescs[entname] = entityDescs[entname] || { name: entname })
-      entdesc.plural = origentname
-
-      names(entdesc, entname)
+  // Analyze paths ending in .../foo/{foo}
+  each(paths, (pathdef, pathstr) => {
 
-      entdesc.alias = entdesc.alias || {}
-
-      if ('id' != m[2]) {
-        entdesc.alias.id = m[2]
-        entdesc.alias[m[2]] = 'id'
-      }
-
-      entdesc.path = (entdesc.path || {})
+    // Look for rightmmost /entname/{entid}.
+    const m = pathstr.match(/\/([a-zA-Z0-1_-]+)\/\{([a-zA-Z0-1_-]+)\}$/)
+    if (m) {
+      const entdesc = resolveEntity(entityDescs, pathstr, m[1], m[2])
 
-      const op: Record<string, any> = {}
-      entdesc.path[pathname] = { op }
 
       each(pathdef, (mdef, method) => {
         const opname = METHOD_IDOP[method]
@@ -71,27 +71,27 @@ function resolveEntityDescs(ctx: any) {
         const resokdef = mdef.responses[200] || mdef.responses[201]
         const resbody = resokdef?.content?.['application/json']?.schema
         if (resbody) {
-          if (resbody[origentname]) {
-            // TODO: use quotes when @voxgig/struct updated to support them
-            // transform.resform = '`body."'+origentname+'"`'
-            transform.resform = '`body.' + origentname + '`'
+          if (resbody[entdesc.origname]) {
+            transform.resform = '`body.' + entdesc.origname + '`'
           }
-          else if (resbody[entname]) {
-            transform.resform = '`body.' + entname + '`'
+          else if (resbody[entdesc.name]) {
+            transform.resform = '`body.' + entdesc.name + '`'
           }
         }
 
         const reqdef = mdef.requestBody?.content?.['application/json']?.schema?.properties
         if (reqdef) {
-          if (reqdef[origentname]) {
-            transform.reqform = { [origentname]: '`reqdata`' }
+          if (reqdef[entdesc.origname]) {
+            transform.reqform = { [entdesc.origname]: '`reqdata`' }
           }
-          else if (reqdef[entname]) {
-            transform.reqform = { [entname]: '`reqdata`' }
+          else if (reqdef[entdesc.origname]) {
+            transform.reqform = { [entdesc.origname]: '`reqdata`' }
           }
 
         }
 
+        const op = entdesc.path[pathstr].op
+
         op[opname] = {
           // TODO: in actual guide, remove "standard" method ops since redundant
           method,
@@ -104,41 +104,33 @@ function resolveEntityDescs(ctx: any) {
     }
   })
 
+  // Analyze paths ending in .../foo
+  each(paths, (pathdef, pathstr) => {
 
-  each(paths, (pathdef, pathname) => {
-    // look for rightmmost /entname/{entid}
-    const m = pathname.match(/\/([a-zA-Z0-1_-]+)$/)
+    // Look for rightmmost /entname.
+    const m = pathstr.match(/\/([a-zA-Z0-1_-]+)$/)
     if (m) {
-      let origentname = snakify(m[1])
-      let entname = depluralize(origentname)
-
-      let entdesc = entityDescs[entname]
-
-      if (entdesc) {
-        entdesc.path = (entdesc.path || {})
-
-        if (pathdef.get) {
-          const op: Record<string, any> = { list: { method: 'get' } }
-          entdesc.path[pathname] = { op }
-
-          const transform: Record<string, any> = {}
-          const mdef = pathdef.get
-          const resokdef = mdef.responses[200] || mdef.responses[201]
-          const resbody = resokdef?.content?.['application/json']?.schema
-          if (resbody) {
-            if (resbody[origentname]) {
-              // TODO: use quotes when @voxgig/struct updated to support them
-              // transform.resform = '`body."'+origentname+'"`'
-              transform.resform = '`body.' + origentname + '`'
-            }
-            else if (resbody[entname]) {
-              transform.resform = '`body.' + entname + '`'
-            }
-          }
+      const entdesc = resolveEntity(entityDescs, pathstr, m[1])
 
-          if (0 < Object.entries(transform).length) {
-            op.transform = transform
+      if (pathdef.get) {
+        const op: Record<string, any> = { list: { method: 'get' } }
+        entdesc.path[pathstr] = { op }
+
+        const transform: Record<string, any> = {}
+        const mdef = pathdef.get
+        const resokdef = mdef.responses[200] || mdef.responses[201]
+        const resbody = resokdef?.content?.['application/json']?.schema
+        if (resbody) {
+          if (resbody[entdesc.origname]) {
+            transform.resform = '`body.' + entdesc.origname + '`'
           }
+          else if (resbody[entdesc.name]) {
+            transform.resform = '`body.' + entdesc.name + '`'
+          }
+        }
+
+        if (0 < Object.entries(transform).length) {
+          op.transform = transform
         }
       }
     }
@@ -148,75 +140,36 @@ function resolveEntityDescs(ctx: any) {
 }
 
 
-function depluralize(word: string): string {
-  if (!word || word.length === 0) {
-    return word
-  }
-
-  // Common irregular plurals
-  const irregulars: Record<string, string> = {
-    'children': 'child',
-    'men': 'man',
-    'women': 'woman',
-    'teeth': 'tooth',
-    'feet': 'foot',
-    'geese': 'goose',
-    'mice': 'mouse',
-    'people': 'person',
-    'data': 'datum',
-    'criteria': 'criterion',
-    'phenomena': 'phenomenon',
-    'indices': 'index',
-    'matrices': 'matrix',
-    'vertices': 'vertex',
-    'analyses': 'analysis',
-    'axes': 'axis',
-    'crises': 'crisis',
-    'diagnoses': 'diagnosis',
-    'oases': 'oasis',
-    'theses': 'thesis',
-    'appendices': 'appendix'
-  }
+function resolveEntity(
+  entityDescs: Record<string, EntityDesc>,
+  pathStr: string,
+  pathName: string,
+  pathParam?: string
+)
+  : EntityDesc {
+  let origentname = snakify(pathName)
+  let entname = depluralize(origentname)
 
-  if (irregulars[word]) {
-    return irregulars[word]
-  }
+  let entdesc = (entityDescs[entname] = entityDescs[entname] || { name: entname })
+  entdesc.plural = origentname
+  entdesc.origname = origentname
 
-  // Rules for regular plurals (applied in order)
+  names(entdesc, entname)
 
-  // -ies -> -y (cities -> city)
-  if (word.endsWith('ies') && word.length > 3) {
-    return word.slice(0, -3) + 'y'
-  }
+  entdesc.alias = entdesc.alias || {}
 
-  // -ves -> -f or -fe (wolves -> wolf, knives -> knife)
-  if (word.endsWith('ves')) {
-    const stem = word.slice(0, -3)
-    // Check if it should be -fe (like knife, wife, life)
-    if (['kni', 'wi', 'li'].includes(stem)) {
-      return stem + 'fe'
+  if (null != pathParam) {
+    const pathParamCanon = snakify(pathParam)
+    if ('id' != pathParamCanon) {
+      entdesc.alias.id = pathParamCanon
+      entdesc.alias[pathParamCanon] = 'id'
     }
-    return stem + 'f'
-  }
-
-  // -oes -> -o (potatoes -> potato)
-  if (word.endsWith('oes')) {
-    return word.slice(0, -2)
-  }
-
-  // -ses, -xes, -zes, -shes, -ches -> remove -es (boxes -> box)
-  if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('zes') ||
-    word.endsWith('shes') || word.endsWith('ches')) {
-    return word.slice(0, -2)
   }
 
-  // -s -> remove -s (cats -> cat)
-  if (word.endsWith('s') && !word.endsWith('ss')) {
-    return word.slice(0, -1)
-  }
+  entdesc.path = (entdesc.path || {})
+  entdesc.path[pathStr] = { op: {} }
 
-  // If none of the rules apply, return as is
-  return word
+  return entdesc
 }
 
 

package/src/guide.ts

@@ -8,8 +8,6 @@ import { heuristic01 } from './guide/heuristic01'
 
 
 async function resolveGuide(ctx: any) {
-  // console.log('GUIDE CTX', ctx)
-
   let guide: Record<string, any> = ctx.model.main.api.guide
 
   if ('heuristic01' === ctx.opts.strategy) {
@@ -36,10 +34,10 @@ async function resolveGuide(ctx: any) {
 
 
   guideBlocks.push(...each(guide.entity, (entity, entityname) => {
-    guideBlocks.push(`\nentity: ${entityname}: path: {`)
+    guideBlocks.push(`\nentity: ${entityname}: {`)
 
     each(entity.path, (path, pathname) => {
-      guideBlocks.push(`  '${pathname}': op: {`)
+      guideBlocks.push(`  path: '${pathname}': op: {`)
 
       each(path.op, (op, opname) => {
         guideBlocks.push(`    '${opname}': method: ${op.method}`)
@@ -59,8 +57,6 @@ async function resolveGuide(ctx: any) {
 
   const guideSrc = guideBlocks.join('\n')
 
-  // console.log(guideSrc)
-
   return () => {
     File({ name: Path.basename(guideFile) }, () => Content(guideSrc))
 

package/src/transform/entity.ts

@@ -1,11 +1,13 @@
 
 
-import { each } from 'jostraca'
+import { each, snakify } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
 import { fixName } from '../transform'
 
+import { depluralize } from '../utility'
+
 
 const entityTransform: Transform = async function(
   ctx: any,
@@ -30,12 +32,16 @@ const entityTransform: Transform = async function(
       id: {
         name: 'id',
         field: 'id',
-      }
+      },
+      ancestors: []
     }
 
     fixName(entityModel, guideEntity.key$)
 
-    each(guideEntity.path, (guidePath: any) => {
+    let ancestors: string[] = []
+    let ancestorsDone = false
+
+    each(guideEntity.path, (guidePath: any, pathStr: string) => {
       const path = guidePath.key$
       const pathdef = def.paths[path]
 
@@ -50,8 +56,25 @@ const entityTransform: Transform = async function(
         .filter((p: string) => p.startsWith('{'))
         .map((p: string) => p.substring(1, p.length - 1))
 
+      if (!ancestorsDone) {
+        // Find all path sections matching /foo/{..param..} and build ancestors array
+        const paramRegex = /\/([a-zA-Z0-9_-]+)\/\{[a-zA-Z0-9_-]+\}/g
+        let m
+        while ((m = paramRegex.exec(pathStr)) !== null) {
+          // Skip if this is the last section (the entity itself)
+          const remainingPath = pathStr.substring(m.index + m[0].length)
+          if (remainingPath.length > 0) {
+            const ancestorName = depluralize(snakify(m[1]))
+            ancestors.push(ancestorName)
+          }
+        }
+
+        ancestorsDone = true
+      }
     })
 
+    entityModel.ancestors = ancestors
+
     msg += guideEntity.name + ' '
   })