@voxgig/apidef 2.0.0 → 2.1.0

package/src/transform/operation.ts

@@ -1,11 +1,14 @@
 
 
-import { each, getx } from 'jostraca'
+import { each, getx, snakify } from 'jostraca'
+
+import { transform, setprop, getprop } from '@voxgig/struct'
 
 import type { TransformResult } from '../transform'
 
 import { fixName, OPKIND } from '../transform'
 
+import { depluralize } from '../utility'
 
 
 const operationTransform = async function(
@@ -20,30 +23,52 @@ const operationTransform = async function(
 
   let msg = 'operations: '
 
-  const paramBuilder = (paramMap: any, paramDef: any,
-    entityModel: any, pathdef: any,
-    op: any, path: any, entity: any, model: any) => {
-
-    paramMap[paramDef.name] = {
+  const paramBuilder = (
+    paramMap: any,
+    paramDef: any,
+    opModel: any,
+    entityModel: any,
+    pathdef: any,
+    op: any,
+    path: any,
+    entity: any,
+    model: any
+  ) => {
+    const paramSpec: any = paramMap[paramDef.name] = {
       required: paramDef.required
     }
-    fixName(paramMap[paramDef.name], paramDef.name)
+    fixName(paramSpec, paramDef.name)
 
     const type = paramDef.schema ? paramDef.schema.type : paramDef.type
-    fixName(paramMap[paramDef.name], type, 'type')
+    fixName(paramSpec, type, 'type')
+
+    // Path params are always required.
+    opModel.validate.params[paramDef.name] = `\`$${paramSpec.TYPE}\``
   }
 
 
-  const queryBuilder = (queryMap: any, queryDef: any,
-    entityModel: any, pathdef: any,
-    op: any, path: any, entity: any, model: any) => {
-    queryMap[queryDef.name] = {
+  const queryBuilder = (
+    queryMap: any,
+    queryDef: any,
+    opModel: any,
+    entityModel: any,
+    pathdef: any,
+    op: any,
+    path: any,
+    entity: any,
+    model: any
+  ) => {
+    const querySpec: any = queryMap[queryDef.name] = {
       required: queryDef.required
     }
     fixName(queryMap[queryDef.name], queryDef.name)
 
     const type = queryDef.schema ? queryDef.schema.type : queryDef.type
     fixName(queryMap[queryDef.name], type, 'type')
+
+    if (queryDef.required) {
+      opModel.validate.params[queryDef.name] = `\`$${querySpec.TYPE}\``
+    }
   }
 
 
@@ -57,6 +82,7 @@ const operationTransform = async function(
     pathdef: any
   ) => {
     let out
+    let why = 'none'
 
     if (null != op.transform?.[direction]) {
       out = op.transform[direction]
@@ -67,16 +93,12 @@ const operationTransform = async function(
       const mdef = pathdef[method]
 
       // TODO: fix getx
-      const content = 'res' === kind ?
+      // const content = 'res' === kind ?
+      const content = 'resform' === direction ?
         (getx(mdef, 'responses.200.content') ||
           getx(mdef, 'responses.201.content')) :
         getx(mdef, 'requestBody.content')
 
-      // console.log(entityModel)
-      // console.log(mdef)
-      // console.log(getx(mdef, 'responses.200.content'))
-      // console.log(kind, method, pathdef, content)
-
       if (content) {
 
         const schema = content['application/json']?.schema
@@ -86,18 +108,22 @@ const operationTransform = async function(
         const resolveDirectionTransform =
           'resform' === direction ? resolveResponseTransform : resolveRequestTransform
 
-        const transform = resolveDirectionTransform(
-          op,
-          kind,
-          method,
-          mdef,
-          content,
-          schema,
-          propkeys
-        )
+          //const [transform, why]
+          ;[out, why]
+            = resolveDirectionTransform(
+              entityModel,
+              op,
+              kind,
+              direction,
+              method,
+              mdef,
+              content,
+              schema,
+              propkeys
+            )
 
         // out = JSON.stringify(transform)
-        out = transform
+        // out = transform
       }
       else {
         out = 'res' === kind ? '`body`' : '`reqdata`'
@@ -105,23 +131,27 @@ const operationTransform = async function(
     }
 
 
-    return out
+    return [out, why]
   }
 
 
   const resolveResponseTransform = (
+    entityModel: any,
     op: any,
     kind: 'res' | 'req',
+    direction: 'resform' | 'reqform',
     method: string,
     mdef: any,
     content: any,
     schema: any,
     propkeys: any
-  ) => {
+  ): [any, string] => {
+    let why = 'default'
     let transform: any = '`body`'
+    const properties = schema?.properties
 
-    if (null == content || null == schema || null == propkeys) {
-      return transform
+    if (null == content || null == schema || null == propkeys || null == properties) {
+      return [transform, why]
     }
 
     const opname = op.key$
@@ -129,13 +159,18 @@ const operationTransform = async function(
     if ('list' === opname) {
       if ('array' !== schema.type) {
         if (1 === propkeys.length) {
+          why = 'list-single-prop:' + propkeys[0]
           transform = '`body.' + propkeys[0] + '`'
         }
         else {
           // Use sub property that is an array
           for (let pk of propkeys) {
-            if ('array' === schema.properties[pk]?.type) {
+            if ('array' === properties[pk]?.type) {
+              why = 'list-single-array:' + pk
               transform = '`body.' + pk + '`'
+
+              // TODO: if each item has prop === name of entity, use that, get with $EACH
+
               break
             }
           }
@@ -144,13 +179,15 @@ const operationTransform = async function(
     }
     else {
       if ('object' === schema.type) {
-        if (null == schema.properties.id) {
+        if (null == properties.id) {
           if (1 === propkeys.length) {
+            why = 'map-single-prop:' + propkeys[0]
             transform = '`body.' + propkeys[0] + '`'
           }
           else {
             for (let pk of propkeys) {
-              if (schema.properties[pk].properties?.id) {
+              if (properties[pk]?.properties?.id) {
+                why = 'map-sub-prop:' + pk
                 transform = '`body.' + pk + '`'
                 break
               }
@@ -160,23 +197,27 @@ const operationTransform = async function(
       }
     }
 
-    return transform
+    return [transform, why]
   }
 
 
   const resolveRequestTransform = (
+    entityModel: any,
     op: any,
     kind: 'res' | 'req',
+    direction: 'resform' | 'reqform',
     method: string,
     mdef: any,
     content: any,
     schema: any,
     propkeys: any
-  ) => {
-    let transform: any = '`data`'
+  ): [any, string] => {
+    let transform: any = '`reqdata`'
+    let why = 'default'
+    const properties = schema?.properties
 
-    if (null == content || null == schema || null == propkeys) {
-      return transform
+    if (null == content || null == schema || null == propkeys || null == properties) {
+      return [transform, why]
     }
 
     const opname = op.key$
@@ -184,13 +225,15 @@ const operationTransform = async function(
     if ('list' === opname) {
       if ('array' !== schema.type) {
         if (1 === propkeys.length) {
-          transform = { [propkeys[0]]: '`data`' }
+          why = 'list-single-prop:' + propkeys[0]
+          transform = { [propkeys[0]]: '`reqdata`' }
         }
         else {
           // Use sub property that is an array
           for (let pk of propkeys) {
-            if ('array' === schema.properties[pk]?.type) {
-              transform = { [pk]: '`data`' }
+            if ('array' === properties[pk]?.type) {
+              why = 'list-single-array:' + pk
+              transform = { [pk]: '`reqdata`' }
               break
             }
           }
@@ -199,14 +242,16 @@ const operationTransform = async function(
     }
     else {
       if ('object' === schema.type) {
-        if (null == schema.properties.id) {
+        if (null == properties.id) {
           if (1 === propkeys.length) {
-            transform = { [propkeys[0]]: '`data`' }
+            why = 'map-single-prop:' + propkeys[0]
+            transform = { [propkeys[0]]: '`reqdata`' }
           }
           else {
             for (let pk of propkeys) {
-              if (schema.properties[pk].properties?.id) {
-                transform = { [pk]: '`data`' }
+              if (properties[pk]?.properties?.id) {
+                why = 'map-sub-prop:' + pk
+                transform = { [pk]: '`reqdata`' }
                 break
               }
             }
@@ -215,7 +260,7 @@ const operationTransform = async function(
       }
     }
 
-    return transform
+    return [transform, why]
   }
 
 
@@ -225,37 +270,93 @@ const operationTransform = async function(
       const method = op.method
       const kind = OPKIND[opname]
 
-      const em = entityModel.op[opname] = {
+      const [resform, resform_COMMENT] =
+        resolveTransform(entityModel, op, kind, 'resform', pathdef)
+
+      const [reqform, reqform_COMMENT] =
+        resolveTransform(entityModel, op, kind, 'reqform', pathdef)
+
+      const opModel = {
         path: path.key$,
+        pathalt: ([] as any[]),
+
         method,
         kind,
         param: {},
         query: {},
-        // transform: {
-        resform: resolveTransform(entityModel, op, kind, 'resform', pathdef),
-        reqform: resolveTransform(entityModel, op, kind, 'reqform', pathdef),
-        // }
+
+        resform_COMMENT: 'derivation: ' + resform_COMMENT,
+        resform,
+
+        reqform_COMMENT: 'derivation: ' + reqform_COMMENT,
+        reqform,
+
+        validate: {
+          params: { '`$OPEN`': true }
+        }
       }
 
-      fixName(em, op.key$)
+      fixName(opModel, op.key$)
+
+      let params: any[] = []
 
       // Params are in the path
       if (0 < path.params$.length) {
-        let params = getx(pathdef[method], 'parameters?in=path') || []
-        if (Array.isArray(params)) {
-          params.reduce((a: any, p: any) =>
-            (paramBuilder(a, p, entityModel, pathdef, op, path, entity, model), a), em.param)
-        }
+        let sharedparams = getx(pathdef, 'parameters?in=path') || []
+        params = sharedparams.concat(
+          getx(pathdef[method], 'parameters?in=path') || []
+        )
+
+        // if (Array.isArray(params)) {
+        params.reduce((a: any, p: any) =>
+        (paramBuilder(a, p, opModel, entityModel,
+          pathdef, op, path, entity, model), a), opModel.param)
+        //}
       }
 
       // Queries are after the ?
-      let queries = getx(pathdef[op.val$], 'parameters?in!=path') || []
-      if (Array.isArray(queries)) {
-        queries.reduce((a: any, p: any) =>
-          (queryBuilder(a, p, entityModel, pathdef, op, path, entity, model), a), em.query)
+      let sharedqueries = getx(pathdef, 'parameters?in!=path') || []
+      let queries = sharedqueries.concat(getx(pathdef[method], 'parameters?in!=path') || [])
+      queries.reduce((a: any, p: any) =>
+      (queryBuilder(a, p, opModel, entityModel,
+        pathdef, op, path, entity, model), a), opModel.query)
+
+      let pathalt: any[] = []
+      const pathselector = makePathSelector(path.key$) // , params)
+      let before = false
+
+      if (null != entityModel.op[opname]) {
+        pathalt = entityModel.op[opname].pathalt
+
+        // Ordering for pathalts: most to least paramrs, then alphanumberic
+        for (let i = 0; i < pathalt.length; i++) {
+          let current = pathalt[i]
+          before =
+            pathselector.pn$ > current.pn$ ||
+            (pathselector.pn$ === current.pn$ &&
+              pathselector.path <= current.path)
+
+          if (before) {
+            pathalt = [
+              ...pathalt.slice(0, i),
+              pathselector,
+              ...pathalt.slice(i),
+            ]
+            break
+          }
+        }
       }
 
-      return em
+      if (!before) {
+        pathalt.push(pathselector)
+      }
+
+      opModel.path = pathalt[pathalt.length - 1].path
+      opModel.pathalt = pathalt
+
+      entityModel.op[opname] = opModel
+
+      return opModel
     },
 
 
@@ -281,6 +382,22 @@ const operationTransform = async function(
 
   }
 
+  /*
+    console.dir(
+      transform({ guide }, {
+        entity: {
+          '`$PACK`': ['guide.entity', {
+            '`$KEY`': 'name',
+            op: {
+              // load: ['`$IF`', ['`$SELECT`',{path:{'`$ANY`':{op:{load:'`$EXISTS`'}}}}], {
+              load: ['`$IF`', 'path.*.op.load', {
+                path: () => 'foo'
+              }]
+            }
+          }]
+        }
+      }), { depth: null })
+  */
 
   each(guide.entity, (guideEntity: any) => {
     let opcount = 0
@@ -296,6 +413,8 @@ const operationTransform = async function(
           opcount++
         }
       })
+
+
     })
 
     msg += guideEntity.name + '=' + opcount + ' '
@@ -305,6 +424,26 @@ const operationTransform = async function(
 }
 
 
+function makePathSelector(path: string) { // , params: any[]) {
+  let out: any = { path }
+
+  let pn$ = 0
+  for (const m of path.matchAll(/\/[^\/]+\/{([^}]+)\}/g)) {
+    const paramName = depluralize(snakify(m[1]))
+    out[paramName] = true
+    pn$++
+  }
+  out.pn$ = pn$
+
+  // for (let p of params) {
+  //   setprop(out, p.name, getprop(out, p.name, false))
+  //   console.log('SP', p.name, out[p.name])
+  // }
+
+  return out
+}
+
+
 export {
   operationTransform
 }

package/src/transform.ts

@@ -79,6 +79,7 @@ const GuideShape = Gubu({
 type Guide = ReturnType<typeof GuideShape>
 
 
+/*
 async function resolveTransforms(ctx: TransformCtx): Promise<TransformSpec> {
   const { log, model: { main: { api: { guide } } } } = ctx
 
@@ -89,28 +90,27 @@ async function resolveTransforms(ctx: TransformCtx): Promise<TransformSpec> {
   // TODO: parameterize
   const defkind = 'openapi'
   const transformNames = guide.control.transform[defkind].order
-    .split(/\s*,\s*/)
+    .split(/\s*,\s* /)
     .map((t: string) => t.trim())
-    .filter((t: string) => '' != t)
+  .filter((t: string) => '' != t)
 
-  log.info({
-    point: 'transform', note: 'order: ' + transformNames.join(';'),
-    order: transformNames
-  })
+log.info({
+  point: 'transform', note: 'order: ' + transformNames.join(';'),
+  order: transformNames
+})
 
-  try {
-    for (const tn of transformNames) {
-      log.debug({ what: 'transform', transform: tn, note: tn })
-      const transform = await resolveTransform(tn, ctx)
-      tspec.transform.push(transform)
-    }
-  }
-  catch (err: any) {
-    console.log(err)
-    throw err
+try {
+  for (const tn of transformNames) {
+    log.debug({ what: 'transform', transform: tn, note: tn })
+    const transform = await resolveTransform(tn, ctx)
+    tspec.transform.push(transform)
   }
+}
+catch (err: any) {
+  throw err
+}
 
-  return tspec
+return tspec
 }
 
 
@@ -181,7 +181,7 @@ async function processTransforms(
     }
     catch (err: any) {
       // TODO: fix: this error does not get printed
-      console.log(err)
+      console.error(err)
 
       pres.ok = false
       pres.msg += transform.name + ': ' + err.message + '\n'
@@ -196,13 +196,19 @@ async function processTransforms(
 
   return pres
 }
+*/
 
 
 
 function fixName(base: any, name: string, prop = 'name') {
-  base[prop.toLowerCase()] = name.toLowerCase()
-  base[camelify(prop)] = camelify(name)
-  base[prop.toUpperCase()] = name.toUpperCase()
+  if (null != base && 'object' === typeof base && 'string' === typeof name) {
+    base[prop.toLowerCase()] = name.toLowerCase()
+    base[camelify(prop)] = camelify(name)
+    base[prop.toUpperCase()] = name.toUpperCase()
+  }
+  else {
+    // record to a "wierds" log
+  }
 }
 
 
@@ -222,6 +228,6 @@ export {
   fixName,
   OPKIND,
   GuideShape,
-  resolveTransforms,
-  processTransforms,
+  // resolveTransforms,
+  // processTransforms,
 }

package/src/types.ts

@@ -29,11 +29,12 @@ const ModelShape = Gubu({
     sdk: {},
     def: {},
     api: {
-      guide: {}
+      guide: {},
+      entity: {},
     },
   }
 })
-const OpenModelShape = Gubu(Open(ModelShape))
+const OpenModelShape = Gubu(Open(ModelShape), { name: 'Model' })
 
 type Model = ReturnType<typeof ModelShape>
 

package/src/utility.ts

@@ -8,6 +8,26 @@ import type {
 } from './types'
 
 
+function getdlog(
+  tagin?: string,
+  filepath?: string)
+  : ((...args: any[]) => void) &
+  { tag: string, file: string, log: (fp?: string) => any[] } {
+  const tag = tagin || '-'
+  const file = Path.basename(filepath || '-')
+  const g = global as any
+  g.__dlog__ = (g.__dlog__ || [])
+  const dlog = (...args: any[]) =>
+    g.__dlog__.push([tag, file, Date.now(), ...args])
+  dlog.tag = tag
+  dlog.file = file
+  dlog.log = (filepath?: string, f?: string | null) =>
+  (f = null == filepath ? null : Path.basename(filepath),
+    g.__dlog__.filter((n: any[]) => n[0] === tag && (null == f || n[2] === f)))
+  return dlog
+}
+
+
 function loadFile(path: string, what: string, fs: FsUtil, log: Log) {
   try {
     const source = fs.readFileSync(path, 'utf8')
@@ -24,9 +44,97 @@ function formatJsonSrc(jsonsrc: string) {
   return jsonsrc
     .replace(/"([a-zA-Z_][a-zA-Z_0-9]*)": /g, '$1: ')
     .replace(/},/g, '}\n')
+    // .replace(/([a-zA-Z_][a-zA-Z_0-9]*)_COMMENT:/g, '# $1')
+    .replace(/\n(\s*)([a-zA-Z_][a-zA-Z_0-9]*)_COMMENT:\s*"(.*)",/g, '\n\n$1# $2 $3')
+}
+
+
+function depluralize(word: string): string {
+  if (!word || word.length === 0) {
+    return word
+  }
+
+  // Common irregular plurals
+  const irregulars: Record<string, string> = {
+    'analyses': 'analysis',
+    'appendices': 'appendix',
+    'axes': 'axis',
+    'children': 'child',
+    'courses': 'course',
+    'crises': 'crisis',
+    'criteria': 'criterion',
+    'data': 'datum',
+    'diagnoses': 'diagnosis',
+    'feet': 'foot',
+    'furnace': 'furnaces',
+    'geese': 'goose',
+    'horses': 'horse',
+    'house': 'houses',
+    'indices': 'index',
+    'license': 'licenses',
+    'matrices': 'matrix',
+    'men': 'man',
+    'mice': 'mouse',
+    'notice': 'notices',
+    'oases': 'oasis',
+    'people': 'person',
+    'phenomena': 'phenomenon',
+    'practice': 'practices',
+    'promise': 'promises',
+    'teeth': 'tooth',
+    'theses': 'thesis',
+    'vertices': 'vertex',
+    'women': 'woman',
+  }
+
+  if (irregulars[word]) {
+    return irregulars[word]
+  }
+
+  // Rules for regular plurals (applied in order)
+
+  if (word.endsWith('ies') && word.length > 3) {
+    return word.slice(0, -3) + 'y'
+  }
+
+
+  // -ies -> -y (cities -> city)
+  if (word.endsWith('ies') && word.length > 3) {
+    return word.slice(0, -3) + 'y'
+  }
+
+  // -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'
+    }
+    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)
+  }
+
+  // If none of the rules apply, return as is
+  return word
 }
 
 
+/*
 function writeChanged(
   point: string, path: string, content: string,
   fs: FsUtil, log: Log,
@@ -74,10 +182,14 @@ function writeChanged(
     throw err
   }
 }
+*/
 
 
 export {
+  getdlog,
   loadFile,
-  formatJsonSrc
+  formatJsonSrc,
+  depluralize,
+
   // writeChanged,
 }