@voxgig/apidef 2.0.0 → 2.0.2

package/src/transform/operation.ts

@@ -20,30 +20,53 @@ 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) => {
+  const paramBuilder = (
+    paramMap: any,
+    paramDef: any,
+    opModel: any,
+    entityModel: any,
+    pathdef: any,
+    op: any,
+    path: any,
+    entity: any,
+    model: any
+  ) => {
 
-    paramMap[paramDef.name] = {
+    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 +80,7 @@ const operationTransform = async function(
     pathdef: any
   ) => {
     let out
+    let why = 'none'
 
     if (null != op.transform?.[direction]) {
       out = op.transform[direction]
@@ -67,16 +91,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 +106,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,19 +129,22 @@ 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
   ) => {
+    let why = 'default'
     let transform: any = '`body`'
 
     if (null == content || null == schema || null == propkeys) {
@@ -129,12 +156,14 @@ 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) {
+              why = 'list-single-array:' + pk
               transform = '`body.' + pk + '`'
               break
             }
@@ -146,11 +175,13 @@ const operationTransform = async function(
       if ('object' === schema.type) {
         if (null == schema.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) {
+                why = 'map-sub-prop:' + pk
                 transform = '`body.' + pk + '`'
                 break
               }
@@ -160,13 +191,15 @@ 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,
@@ -174,6 +207,7 @@ const operationTransform = async function(
     propkeys: any
   ) => {
     let transform: any = '`data`'
+    let why = 'default'
 
     if (null == content || null == schema || null == propkeys) {
       return transform
@@ -184,12 +218,14 @@ const operationTransform = async function(
     if ('list' === opname) {
       if ('array' !== schema.type) {
         if (1 === propkeys.length) {
+          why = 'list-single-prop:' + propkeys[0]
           transform = { [propkeys[0]]: '`data`' }
         }
         else {
           // Use sub property that is an array
           for (let pk of propkeys) {
             if ('array' === schema.properties[pk]?.type) {
+              why = 'list-single-array:' + pk
               transform = { [pk]: '`data`' }
               break
             }
@@ -201,11 +237,13 @@ const operationTransform = async function(
       if ('object' === schema.type) {
         if (null == schema.properties.id) {
           if (1 === propkeys.length) {
+            why = 'map-single-prop:' + propkeys[0]
             transform = { [propkeys[0]]: '`data`' }
           }
           else {
             for (let pk of propkeys) {
               if (schema.properties[pk].properties?.id) {
+                why = 'map-sub-prop:' + pk
                 transform = { [pk]: '`data`' }
                 break
               }
@@ -215,7 +253,7 @@ const operationTransform = async function(
       }
     }
 
-    return transform
+    return [transform, why]
   }
 
 
@@ -225,26 +263,39 @@ 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 = entityModel.op[opname] = {
         path: path.key$,
         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$)
 
       // 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)
+          (paramBuilder(a, p, opModel, entityModel,
+            pathdef, op, path, entity, model), a), opModel.param)
         }
       }
 
@@ -252,10 +303,11 @@ const operationTransform = async function(
       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)
+        (queryBuilder(a, p, opModel, entityModel,
+          pathdef, op, path, entity, model), a), opModel.query)
       }
 
-      return em
+      return opModel
     },
 
 

package/src/transform.ts

@@ -106,7 +106,6 @@ async function resolveTransforms(ctx: TransformCtx): Promise<TransformSpec> {
     }
   }
   catch (err: any) {
-    console.log(err)
     throw err
   }
 
@@ -181,7 +180,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'

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

@@ -24,9 +24,84 @@ 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> = {
+    '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'
+  }
+
+  if (irregulars[word]) {
+    return irregulars[word]
+  }
+
+  // Rules for regular plurals (applied in order)
+
+  // -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 +149,13 @@ function writeChanged(
     throw err
   }
 }
+*/
 
 
 export {
   loadFile,
-  formatJsonSrc
+  formatJsonSrc,
+  depluralize,
+
   // writeChanged,
 }

package/src/builder/flow/flowHeuristic01.ts~

@@ -1,45 +0,0 @@
-
-
-import { each, snakify, names } from 'jostraca'
-
-
-
-async function flowHeuristic01(ctx: any): Promise<any[]> {
-  let entity = ctx.model.main.api.guide.entity
-
-  const flows: any[] = []
-
-  each(entity, (entity: any) => {
-    flows.push(resolveBasicEntityFlow(ctx, entity))
-  })
-
-  return flows
-}
-
-
-
-
-function resolveBasicEntityFlow(ctx: any, entity: any) {
-  const apiEntity = ctx.apimodel.main.api.entity[entity.name]
-
-  const flow: any = {
-    name: 'Basic' + apiEntity.Name
-  }
-
-  flow.model = ({
-    name: flow.Name,
-    param: {},
-    test: { entity: { [apiEntity.Name]: {} } },
-    step: []
-  } as any)
-
-  names(flow, flow.name)
-
-  return flow
-}
-
-
-
-export {
-  flowHeuristic01
-}