@voxgig/apidef 1.2.0 → 1.3.0

package/src/transform/manual.ts

@@ -3,12 +3,19 @@ import { Jsonic } from '@jsonic/jsonic-next'
 
 import { each, getx } from 'jostraca'
 
-import type { TransformCtx, TransformSpec } from '../transform'
+import type { TransformCtx, TransformSpec, TransformResult, Transform, Guide } from '../transform'
 
 
 const { deep } = Jsonic.util
 
-async function manualTransform(ctx: TransformCtx, tspec: TransformSpec, model: any, def: any) {
+const manualTransform = async function(
+  ctx: TransformCtx,
+  guide: Guide,
+  tspec: TransformSpec,
+  model: any,
+  def: any
+): Promise<TransformResult> {
+
   const { model: { main: { guide: { manual } } } } = ctx
 
   deep(model, manual)

package/src/transform/operation.ts

@@ -2,19 +2,20 @@
 
 import { each, getx } from 'jostraca'
 
-import type { TransformCtx, TransformSpec } from '../transform'
+import type { TransformCtx, TransformSpec, TransformResult, Transform, Guide } from '../transform'
 
-import { fixName } from '../transform'
+import { fixName, OPKIND } from '../transform'
 
 
 
-async function operationTransform(
+const operationTransform = async function(
   ctx: TransformCtx,
+  guide: Guide,
   tspec: TransformSpec,
   model: any,
   def: any
-) {
-  const { model: { main: { guide } } } = ctx
+): Promise<TransformResult> {
+
   let msg = 'operations: '
 
   const paramBuilder = (paramMap: any, paramDef: any,
@@ -43,19 +44,115 @@ async function operationTransform(
     fixName(queryMap[queryDef.name], type, 'type')
   }
 
+
+  // Resolve the JSON path to the data (the "place").
+  const resolvePlace = (op: any, kind: 'res' | 'req', pathdef: any) => {
+    const opname = op.key$
+    // console.log('RP', kind, op)
+
+    let place = null == op.place ? '' : op.place
+
+    if (null != place && '' !== place) {
+      return place
+    }
+
+    const method = op.method
+    const mdef = pathdef[method]
+
+    // TODO: fix getx
+    const content = 'res' === kind ?
+      (getx(mdef, 'responses.200.content') ||
+        getx(mdef, 'responses.201.content')) :
+      getx(mdef, 'requestBody.content')
+
+
+    // console.log('RP', kind, op, 'content', null == content)
+
+    if (null == content) {
+      return place
+    }
+
+    const schema = content['application/json']?.schema
+
+    // console.log('RP', kind, op, 'schema', null == schema)
+
+    if (null == schema) {
+      return place
+    }
+
+
+    const propkeys = null == schema.properties ? [] : Object.keys(schema.properties)
+
+    // HEURISTIC: guess place
+    if ('list' === opname) {
+      if ('array' === schema.type) {
+        place = ''
+      }
+      else {
+        if (1 === propkeys.length) {
+          place = propkeys[0]
+        }
+        else {
+          // Use sub property that is an array
+          for (let pk of propkeys) {
+            if ('array' === schema.properties[pk]?.type) {
+              place = pk
+              break
+            }
+          }
+        }
+      }
+    }
+    else {
+      if ('object' === schema.type) {
+        if (schema.properties.id) {
+          place = '' // top level
+        }
+        else {
+          if (1 === propkeys.length) {
+            place = propkeys[0]
+          }
+          else {
+            // Use sub property with an id
+            for (let pk of propkeys) {
+              if (schema.properties[pk].properties?.id) {
+                place = pk
+                break
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // console.log('PLACE', op, kind, schema.type, 'P=', place)
+    return place
+  }
+
+
   const opBuilder: any = {
     any: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      const em = entityModel.op[op.key$] = {
+      // console.log('OP', op, pathdef, path, entity)
+      const opname = op.key$
+      const method = op.val$
+      const kind = OPKIND[opname]
+
+      // console.log('EM', entityModel.name)
+
+      const em = entityModel.op[opname] = {
         path: path.key$,
         method: op.val$,
+        kind,
         param: {},
         query: {},
+        place: resolvePlace(op, kind, pathdef)
       }
+
       fixName(em, op.key$)
 
       // Params are in the path
       if (0 < path.params$.length) {
-        let params = getx(pathdef[op.val$], 'parameters?in=path') || []
+        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)
@@ -85,7 +182,7 @@ async function operationTransform(
       return opBuilder.any(entityModel, pathdef, op, path, entity, model)
     },
 
-    save: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
+    update: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
       return opBuilder.any(entityModel, pathdef, op, path, entity, model)
     },
 

package/src/transform/top.ts

@@ -1,18 +1,24 @@
 
 import { each, getx } from 'jostraca'
 
-import type { TransformCtx, TransformSpec } from '../transform'
+import type { TransformCtx, TransformSpec, TransformResult, Transform, Guide } from '../transform'
 
 import { fixName } from '../transform'
 
 
-async function topTransform(ctx: TransformCtx, tspec: TransformSpec, model: any, def: any) {
+const topTransform = async function(
+  ctx: TransformCtx,
+  guide: Guide,
+  tspec: TransformSpec,
+  model: any,
+  def: any
+): Promise<TransformResult> {
   const { spec } = ctx
 
-  // fixName(model.main.api, spec.meta.name)
-  model.main.def.desc = def.info.description
+  model.main.def.info = def.info
+  model.main.def.servers = def.servers
 
-  return { ok: true, msg: 'top' } // , msg: spec.meta.name }
+  return { ok: true, msg: 'top' }
 }
 
 

package/src/transform.ts

@@ -5,6 +5,7 @@ import Path from 'node:path'
 
 import { getx, each, camelify } from 'jostraca'
 
+import { Gubu, Child, Exact } from 'gubu'
 
 import { topTransform } from './transform/top'
 import { entityTransform } from './transform/entity'
@@ -36,6 +37,7 @@ type TransformResult = {
 
 type Transform = (
   ctx: TransformCtx,
+  guide: Guide,
   tspec: TransformSpec,
   apimodel: any,
   def: any,
@@ -58,6 +60,35 @@ const TRANSFORM: Record<string, Transform> = {
 
 
 
+const OPKIND: any = {
+  list: 'res',
+  load: 'res',
+  remove: 'res',
+  create: 'req',
+  update: 'req',
+}
+
+
+const GuideShape = Gubu({
+  /*
+  entity: Child({
+    key$: '',
+    name: String,
+    path: Child({
+      op: Child({
+        method: Exact('get', 'post', 'put', 'patch', 'delete'),
+        place: ''
+      })
+    })
+    }),
+  */
+  entity: {},
+  control: {},
+  transform: {},
+})
+
+type Guide = ReturnType<typeof GuideShape>
+
 
 async function resolveTransforms(ctx: TransformCtx): Promise<TransformSpec> {
   const { log, model: { main: { guide } } } = ctx
@@ -143,11 +174,14 @@ async function processTransforms(
     results: []
   }
 
+  const guide: Guide = GuideShape(ctx.model.main.guide)
+
+
   for (let tI = 0; tI < spec.transform.length; tI++) {
     const transform = spec.transform[tI]
 
     try {
-      const tres = await transform(ctx, spec, apimodel, def)
+      const tres = await transform(ctx, guide, spec, apimodel, def)
       pres.ok = pres.ok && tres.ok
       pres.results.push(tres)
     }
@@ -193,11 +227,16 @@ function fixName(base: any, name: string, prop = 'name') {
 export type {
   TransformCtx,
   TransformSpec,
+  Transform,
+  TransformResult,
+  Guide,
 }
 
 
 export {
   fixName,
+  OPKIND,
+  GuideShape,
   resolveTransforms,
   processTransforms,
 }