@voxgig/apidef 2.4.1 → 3.0.2

package/src/transform/operation.ts

@@ -1,475 +1,179 @@
 
 
-import { each, getx, snakify } from 'jostraca'
+import { each, snakify } from 'jostraca'
 
-import { transform, setprop, getprop } from '@voxgig/struct'
+import { getelem, isempty } from '@voxgig/struct'
 
-import type { TransformResult } from '../transform'
+import type { TransformResult, Transform } from '../transform'
 
-import { fixName, OPKIND } from '../transform'
+import { fixName } from '../transform'
 
-import { depluralize } from '../utility'
+import { formatJSONIC } from '../utility'
 
+import { KIT } from '../types'
 
-const operationTransform = async function(
-  ctx: any,
-): Promise<TransformResult> {
-  const { apimodel, model, def, guide } = ctx
-
-  let msg = 'operations: '
-
-  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(paramSpec, paramDef.name)
+import type { KitModel } from '../types'
 
-    const type = paramDef.schema ? paramDef.schema.type : paramDef.type
-    fixName(paramSpec, type, 'type')
+import type {
+  GuideEntity,
+} from './top'
 
-    // Path params are always required.
-    opModel.validate.params[paramDef.name] = `\`$${paramSpec.TYPE}\``
-  }
+import type {
+  GuideOp,
+  PathDesc,
+} from '../desc'
 
+import type {
+  OpName,
+  ModelOpMap,
+  ModelOp,
+  ModelAlt,
+} from '../model'
 
-  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}\``
-    }
-  }
-
-
-  // Resolve the JSON structure of the request or response.
-  // NOTE: uses heuristics.
-  const resolveTransform = (
-    entityModel: any,
-    op: any,
-    kind: 'res' | 'req',
-    direction: 'resform' | 'reqform',
-    pathdef: any
-  ) => {
-    let out
-    let why = 'none'
-
-    if (null != op.transform?.[direction]) {
-      out = op.transform[direction]
-    }
-
-    else {
-      const method = op.method
-      const mdef = pathdef[method]
-
-      // TODO: fix getx
-      // const content = 'res' === kind ?
-      const content = 'resform' === direction ?
-        (getx(mdef, 'responses.200.content') ||
-          getx(mdef, 'responses.201.content')) :
-        getx(mdef, 'requestBody.content')
-
-      if (content) {
-
-        const schema = content['application/json']?.schema
-
-        const propkeys = null == schema?.properties ? [] : Object.keys(schema.properties)
-
-        const resolveDirectionTransform =
-          'resform' === direction ? resolveResponseTransform : resolveRequestTransform
-
-          //const [transform, why]
-          ;[out, why]
-            = resolveDirectionTransform(
-              entityModel,
-              op,
-              kind,
-              direction,
-              method,
-              mdef,
-              content,
-              schema,
-              propkeys
-            )
-
-        // out = JSON.stringify(transform)
-        // out = transform
-      }
-      else {
-        out = 'res' === kind ? '`body`' : '`reqdata`'
-      }
-    }
+const operationTransform = async function(
+  ctx: any,
+): Promise<TransformResult> {
+  const { apimodel, guide } = ctx
+  const kit = apimodel.main[KIT]
 
+  let msg = 'operation '
 
-    return [out, why]
-  }
 
+  each(guide.entity, (gent: GuideEntity, entname: string) => {
+    collectOps(gent)
 
-  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 || null == properties) {
-      return [transform, why]
+    const opm: ModelOpMap = {
+      load: undefined,
+      list: undefined,
+      create: undefined,
+      update: undefined,
+      delete: undefined,
+      patch: undefined,
     }
 
-    const opname = op.key$
+    resolveLoad(opm, gent)
+    resolveList(opm, gent)
+    resolveCreate(opm, gent)
+    resolveUpdate(opm, gent)
+    resolveDelete(opm, gent)
+    resolvePatch(opm, gent)
 
-    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' === 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
-            }
-          }
-        }
-      }
-    }
-    else {
-      if ('object' === schema.type) {
-        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 (properties[pk]?.properties?.id) {
-                why = 'map-sub-prop:' + pk
-                transform = '`body.' + pk + '`'
-                break
-              }
-            }
-          }
-        }
-      }
-    }
-
-    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
-  ): [any, string] => {
-    let transform: any = '`reqdata`'
-    let why = 'default'
-    const properties = schema?.properties
-
-    if (null == content || null == schema || null == propkeys || null == properties) {
-      return [transform, why]
-    }
+    kit.entity[entname].op = opm
 
-    const opname = op.key$
+    msg += gent.name + ' '
+  })
 
-    if ('list' === opname) {
-      if ('array' !== schema.type) {
-        if (1 === propkeys.length) {
-          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' === properties[pk]?.type) {
-              why = 'list-single-array:' + pk
-              transform = { [pk]: '`reqdata`' }
-              break
-            }
-          }
-        }
-      }
-    }
-    else {
-      if ('object' === schema.type) {
-        if (null == properties.id) {
-          if (1 === propkeys.length) {
-            why = 'map-single-prop:' + propkeys[0]
-            transform = { [propkeys[0]]: '`reqdata`' }
-          }
-          else {
-            for (let pk of propkeys) {
-              if (properties[pk]?.properties?.id) {
-                why = 'map-sub-prop:' + pk
-                transform = { [pk]: '`reqdata`' }
-                break
-              }
-            }
-          }
-        }
-      }
-    }
+  return { ok: true, msg }
+}
 
-    return [transform, why]
-  }
 
+function collectOps(gent: GuideEntity) {
+  gent.opm$ = gent.opm$ ?? {}
+  each(gent.paths$, (pathdesc: PathDesc) => {
+    each(pathdesc.op, (gop: GuideOp, opname: OpName) => {
+      gent.opm$[opname] = gent.opm$[opname] ?? { paths: [] }
 
-  const opBuilder: any = {
-    any: (
-      entityModel: any,
-      pathdef: any,
-      guideOp: any,
-      guidePath: any,
-      guideEntity: any,
-      model: any
-    ) => {
-      if (false === guidePath.active) {
-        return
+      const oppathdesc: PathDesc = {
+        orig: pathdesc.orig,
+        parts: pathdesc.parts,
+        rename: pathdesc.rename,
+        method: gop.method,
+        op: pathdesc.op,
+        def: pathdesc.def,
       }
 
-      const opname = guideOp.key$
-      const method = guideOp.method
-      const kind = OPKIND[opname]
-
-      const existingOpModel = entityModel.op[opname]
-      const existingParam = existingOpModel?.param
-
-      const [resform, resform_COMMENT] =
-        resolveTransform(entityModel, guideOp, kind, 'resform', pathdef)
-
-      const [reqform, reqform_COMMENT] =
-        resolveTransform(entityModel, guideOp, kind, 'reqform', pathdef)
-
-      const opModel = {
-        path: guidePath.key$,
-        pathalt: ([] as any[]),
-
-        method,
-        kind,
-        param: existingParam || {},
-        query: {},
-
-        resform_COMMENT: 'derivation: ' + resform_COMMENT,
-        resform,
-
-        reqform_COMMENT: 'derivation: ' + reqform_COMMENT,
-        reqform,
-
-        validate: {
-          params: { '`$OPEN`': true }
-        }
-      }
+      gent.opm$[opname].paths.push(oppathdesc)
+    })
+  })
+}
 
-      fixName(opModel, guideOp.key$)
 
-      let params: any[] = []
 
-      // Params are in the path
-      if (0 < guidePath.params$.length) {
-        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, guideOp, guidePath, guideEntity, model), a), opModel.param)
-        //}
-      }
 
-      // Queries are after the ?
-      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, guideOp, guidePath, guideEntity, model), a), opModel.query)
-
-      let pathalt: any[] = []
-      const pathselector = makePathSelector(guidePath.key$)
-
-      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
-          }
-        }
-      }
+function resolveLoad(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.load = resolveOp('load', gent)
+  return opdesc
+}
 
-      if (!before) {
-        pathalt.push(pathselector)
-      }
 
-      opModel.path = pathalt[pathalt.length - 1].path
-      opModel.pathalt = pathalt
+function resolveList(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.list = resolveOp('list', gent)
+  return opdesc
+}
 
-      entityModel.op[opname] = opModel
 
-      return opModel
-    },
+function resolveCreate(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.create = resolveOp('create', gent)
+  return opdesc
+}
 
 
-    list: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
+function resolveUpdate(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.update = resolveOp('update', gent)
+  return opdesc
+}
 
-    load: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
 
-    create: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
+function resolveDelete(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = opm.delete = resolveOp('delete', gent)
+  return opdesc
+}
 
-    update: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
 
-    remove: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
+function resolvePatch(opm: ModelOpMap, gent: GuideEntity): undefined | ModelOp {
+  const opdesc = resolveOp('patch', gent)
 
+  // If patch is actually update, make it update!
+  if (null != opdesc && null == opm.update) {
+    opm.update = opdesc
+    opm.update.name = 'update'
+  }
+  else {
+    opm.patch = opdesc
   }
 
-  /*
-    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 })
-  */
+  return opdesc
+}
 
-  each(guide.entity, (guideEntity: any) => {
-    let opcount = 0
-    const entityModel = apimodel.main.api.entity[guideEntity.key$]
-    each(guideEntity.path, (guidePath: any) => {
-      const pathdef = def.paths[guidePath.key$]
 
-      each(guidePath.op, (guideOp: any) => {
-        const opbuild = opBuilder[guideOp.key$]
+function resolveOp(opname: OpName, gent: GuideEntity): undefined | ModelOp {
+  let mop: undefined | ModelOp = undefined
+  let opdesc = gent.opm$[opname]
+  if (opdesc) {
+    // console.dir(opdesc, { depth: null })
 
-        if (opbuild) {
-          opbuild(entityModel, pathdef, guideOp, guidePath, guideEntity, model)
-          opcount++
-        }
-      })
-    })
+    mop = {
+      name: opname,
+      alts: opdesc.paths.map(p => {
+        const parts = applyRename(p)
 
-    // Full list of params only know after all operations built.
-    each(entityModel.op, (op: any) => {
-      const params = Object.keys(op.param || {})
-      const pathalt = op.pathalt || []
-
-      // if ('course' === entityModel.name) {
-      //   console.log('PA', params, pathalt)
-      // }
-
-      for (const pa of pathalt) {
-        for (const p of params) {
-          pa[p] = pa[p] || false
-          // if ('course' === entityModel.name) {
-          //   console.log('PA-SET', p, pa)
-          // }
+        const malt: ModelAlt = {
+          orig: p.orig,
+          parts,
+          method: p.method,
+          args: {},
+          select: {}
         }
-      }
-    })
 
-    // if ('course' === entityModel.name) {
-    //   console.dir(entityModel, { depth: null })
-    // }
-
-    msg += guideEntity.name + '=' + opcount + ' '
-  })
-
-  return { ok: true, msg }
+        return malt
+      })
+    }
+  }
+  return mop
 }
 
 
-function makePathSelector(path: string) {
-  let out: any = { path }
+function applyRename(pathdesc: PathDesc): string[] {
+  const prn: Record<string, string> = pathdesc.rename?.param ?? {}
+  return pathdesc.parts.map(p => '{' === p[0] ? (prn[p.substring(1, p.length - 1)] ?? p) : p)
+}
 
-  let pn$ = 0
-  for (const m of path.matchAll(/\/[^\/]+\/{([^}]+)\}/g)) {
-    const paramName = depluralize(snakify(m[1]))
-    out[paramName] = true
-    pn$++
-  }
-  out.pn$ = pn$
 
-  return out
-}
 
 
 export {
-  operationTransform
+  operationTransform,
 }

package/src/transform/select.ts

@@ -0,0 +1,90 @@
+
+
+import { each, snakify } from 'jostraca'
+
+import type { TransformResult, Transform } from '../transform'
+
+import { formatJSONIC, depluralize, validator } from '../utility'
+
+
+import { KIT } from '../types'
+
+import type {
+  KitModel,
+  Guide,
+} from '../types'
+
+import type {
+  PathDef,
+  ParameterDef,
+  MethodDef,
+} from '../def'
+
+import type {
+  OpName,
+  ModelOp,
+  ModelEntity,
+  ModelAlt,
+  ModelArg,
+} from '../model'
+
+
+
+const selectTransform = async function(
+  ctx: any,
+): Promise<TransformResult> {
+  const { apimodel, def, guide } = ctx
+  const kit: KitModel = apimodel.main[KIT]
+
+  let msg = 'select '
+
+  each(kit.entity, (ment: ModelEntity, entname: string) => {
+    each(ment.op, (mop: ModelOp, opname: OpName) => {
+      each(mop.alts, (malt: ModelAlt) => {
+        const pdef: PathDef = def.paths[malt.orig]
+        resolveSelect(guide, ment, mop, malt, pdef)
+      })
+    })
+
+    msg += ment.name + ' '
+  })
+
+  return { ok: true, msg }
+}
+
+
+function resolveSelect(guide: Guide, ment: ModelEntity, mop: ModelOp, malt: ModelAlt, pdef: PathDef) {
+  const select: any = malt.select
+  const margs: any = malt.args
+
+  const argkinds = ['param', 'query', 'header', 'cookie']
+
+  argkinds.map((kind: string) => {
+    each(margs[kind], (marg: ModelArg) => {
+      select[kind] = (select[kind] ?? {})
+
+      if (marg.req) {
+        select[kind][marg.name] = true
+      }
+    })
+  })
+
+  const gent = guide.entity[ment.name]
+  const gpath = gent.path[malt.orig]
+
+  // console.log('GPATH', gpath)
+
+  if (gpath.action) {
+    const actname = Object.keys(gpath.action)[0]
+
+    if (null != actname) {
+      select.$action = actname
+    }
+  }
+
+}
+
+
+export {
+  selectTransform,
+}