@voxgig/apidef 2.4.1 → 3.0.2

package/src/transform/entity.ts

@@ -1,74 +1,57 @@
 
 
-import { each, snakify } from 'jostraca'
+import { each } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
-import { fixName } from '../transform'
+import { formatJSONIC } from '../utility'
 
-import { depluralize } from '../utility'
+import { KIT } from '../types'
 
+import type { KitModel } from '../types'
 
-const entityTransform: Transform = async function(
+import type {
+  GuideEntity,
+} from './top'
+
+import type {
+  GuidePath,
+  PathDesc,
+} from '../desc'
+
+import type {
+  ModelEntity,
+} from '../model'
+
+
+
+
+const entityTransform = async function(
   ctx: any,
 ): Promise<TransformResult> {
-  const { apimodel, model, def, guide } = ctx
+  const { apimodel, guide } = ctx
+  const kit: KitModel = apimodel.main[KIT]
 
   let msg = ''
 
-  each(guide.entity, (guideEntity: any) => {
-    const entityName = guideEntity.key$
-    ctx.log.debug({ point: 'guide-entity', note: entityName })
+  each(guide.entity, (guideEntity: GuideEntity, entname: string) => {
+    ctx.log.debug({ point: 'guide-entity', note: entname })
+
+    const paths$ = resolvePathList(guideEntity, ctx.def)
+    const relations = buildRelations(guideEntity, paths$)
 
-    const entityModel: any = apimodel.main.api.entity[entityName] = {
+    const modelent: ModelEntity = {
+      name: entname,
       op: {},
-      field: {},
-      cmd: {},
+      fields: [],
       id: {
         name: 'id',
         field: 'id',
       },
-      ancestors: []
+      relations,
     }
 
-    fixName(entityModel, guideEntity.key$)
-
-    let ancestors: string[] = []
-    let ancestorsDone = false
-
-    each(guideEntity.path, (guidePath: any, pathStr: string) => {
-      const path = guidePath.key$
-      const pathdef = def.paths[path]
-
-      if (null == pathdef) {
-        throw new Error('path not found in OpenAPI: ' + path +
-          ' (entity: ' + guideEntity.name + ')')
-      }
-
-      // TODO: is this needed?
-      guidePath.parts$ = path.split('/')
-      guidePath.params$ = guidePath.parts$
-        .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
+    kit.entity[entname] = modelent
 
     msg += guideEntity.name + ' '
   })
@@ -77,6 +60,72 @@ const entityTransform: Transform = async function(
 }
 
 
+
+function resolvePathList(guideEntity: GuideEntity, def: { paths: Record<string, any> }) {
+  const paths$: PathDesc[] = []
+
+  each(guideEntity.path, (guidePath: GuidePath, orig: string) => {
+    const parts = orig.split('/').filter(p => '' != p)
+    const rename = guidePath.rename ?? {}
+
+    each(rename.param, (param: any) => {
+      const pI = parts.indexOf('{' + param.key$ + '}')
+      parts[pI] = '{' + param.val$ + '}'
+    })
+
+    const pathdesc: PathDesc = {
+      orig,
+      parts,
+      rename,
+      method: '', // operation collectOps will copy and assign per op
+      op: guidePath.op,
+      def: def.paths[orig],
+    }
+
+    paths$.push(pathdesc)
+  })
+
+  guideEntity.paths$ = paths$
+
+  return paths$
+}
+
+
+
+function buildRelations(guideEntity: any, paths$: PathDesc[]) {
+  let ancestors: any[] = paths$
+    .map(pli => pli.parts
+      .map((p, i) =>
+        (pli.parts[i + 1]?.[0] === '{' && pli.parts[i + 1] !== '{id}') ? p : null)
+      .filter(p => null != p))
+    .filter(n => 0 < n.length)
+    .sort((a, b) => a.length - b.length)
+
+  // remove suffixes
+  ancestors = ancestors
+    .reduce((a, n, j) =>
+    ((0 < (ancestors.slice(j + 1).filter(p => suffix(p, n))).length
+      ? null : a.push(n)), a), [])
+
+  const relations = {
+    ancestors
+  }
+
+  guideEntity.relations$ = relations
+
+  return relations
+}
+
+
+// True if array c is a suffix of array p,
+function suffix(p: string[], c: string[]): boolean {
+  return c.reduce((b, _, i) => (b && c[c.length - 1 - i] === p[p.length - 1 - i]), true)
+}
+
+
+
 export {
-  entityTransform
+  resolvePathList,
+  buildRelations,
+  entityTransform,
 }

package/src/transform/field.ts

@@ -2,120 +2,199 @@
 
 import { each, getx } from 'jostraca'
 
+import { getelem } from '@voxgig/struct'
+
 import type { TransformResult, Transform } from '../transform'
 
 import { fixName } from '../transform'
 
+import { formatJSONIC, validator, canonize } from '../utility'
+
+import { KIT } from '../types'
+
+import type { KitModel } from '../types'
+
+import type {
+  PathDef,
+  ParameterDef,
+  MethodDef,
+  SchemaDef,
+} from '../def'
+
+import type {
+  GuideEntity,
+} from './top'
 
+import type {
+  GuideOp,
+  PathDesc,
+} from '../desc'
 
-const fieldTransform: Transform = async function(
+import type {
+  OpName,
+  ModelOpMap,
+  ModelOp,
+  ModelEntity,
+  ModelAlt,
+  ModelArg,
+  ModelField,
+} from '../model'
+
+
+
+const fieldTransform = async function(
   ctx: any,
 ): Promise<TransformResult> {
-  const { apimodel, model, def, guide } = ctx
+  const { apimodel, def } = ctx
+  const kit: KitModel = apimodel.main[KIT]
+
+  let msg = 'field '
+
+  const opFieldPrecedence: OpName[] = ['load', 'create', 'update', 'patch', 'list']
 
-  let msg = 'fields: '
+  each(kit.entity, (ment: ModelEntity, entname: string) => {
+    const fielddefs: SchemaDef[] = []
 
-  each(guide.entity, (guideEntity: any) => {
-    const entityName = guideEntity.key$
-    const entityModel = apimodel.main.api.entity[entityName]
+    const fields = ment.fields
+    const seen: any = {}
 
-    let fieldCount = 0
-    each(guideEntity.path, (guidePath: any) => {
-      const path = guidePath.key$
-      const pathdef = def.paths[path]
+    for (let opname of opFieldPrecedence) {
+      const mop = ment.op[opname]
+      if (mop) {
+        const malts = mop.alts
 
-      each(guidePath.op, (op: any) => {
-        const opname = op.key$
+        for (let malt of malts) {
+          const opfields = resolveOpFields(ment, mop, malt, def)
 
-        if ('load' === opname) {
-          fieldCount = fieldbuild(entityModel, pathdef, op, guidePath, guideEntity, model)
+          for (let opfield of opfields) {
+            if (!seen[opfield.name]) {
+              fields.push(opfield)
+              seen[opfield.name] = opfield
+            }
+            else {
+              mergeField(ment, mop, malt, def, seen[opfield.name], opfield)
+            }
+          }
         }
+      }
+    }
 
-      })
+    fields.sort((a: ModelField, b: ModelField) => {
+      return a.name < b.name ? -1 : a.name > b.name ? 1 : 0
     })
 
-    msg += guideEntity.name + '=' + fieldCount + ' '
+    msg += ment.name + ' '
   })
 
   return { ok: true, msg }
 }
 
 
-function fieldbuild(
-  entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any
-) {
-  let fieldCount = 0
-  let fieldSets = getx(pathdef.get, 'responses 200 content "application/json" schema')
 
-  if (fieldSets) {
-    if (Array.isArray(fieldSets.allOf)) {
-      fieldSets = fieldSets.allOf
-    }
-    else if (fieldSets.properties) {
-      fieldSets = [fieldSets]
+function resolveOpFields(
+  ment: ModelEntity,
+  mop: ModelOp,
+  malt: ModelAlt,
+  def: any
+): ModelField[] {
+  const mfields: ModelField[] = []
+  const fielddefs = findFieldDefs(ment, mop, malt, def)
+
+  for (let fielddef of fielddefs) {
+    const fieldname = (fielddef as any).key$ as string
+    const mfield: ModelField = {
+      name: canonize(fieldname),
+      type: validator(fielddef.type),
+      req: !!fielddef.required,
+      op: {},
     }
+    mfields.push(mfield)
   }
 
-  each(fieldSets, (fieldSet: any) => {
-    each(fieldSet.properties, (property: any) => {
-      const field =
-        (entityModel.field[property.key$] = entityModel.field[property.key$] || {})
+  return mfields
+}
 
-      field.name = property.key$
-      fixName(field, field.name)
 
-      // field.type = property.type
-      resolveFieldType(entityModel, field, property)
-      fixName(field, field.type, 'type')
+function findFieldDefs(
+  ment: ModelEntity,
+  mop: ModelOp,
+  malt: ModelAlt,
+  def: any
+): SchemaDef[] {
+  const fielddefs: SchemaDef[] = []
+  const pathdef = def.paths[malt.orig]
 
-      field.short = property.description
+  const method = malt.method.toLowerCase()
+  const opdef: any = pathdef[method]
 
-      fieldCount++
-    })
-  })
+  if (opdef) {
+    const responses = opdef.responses
+    const requestBody = opdef.requestBody
 
-  // Guess id field name using GET path param
-  if ('load' === op.key$) {
-    const getdef = pathdef.get
-    const getparams = getdef.parameters || []
-    if (1 === getparams.length) {
-      if (entityModel.op.load.path.match(RegExp('\\{' + getdef.parameters[0].name + '\\}$'))) {
-        entityModel.id.field = getdef.parameters[0].name
+    let fieldSets
+
+    if (responses) {
+      fieldSets = getx(responses, '200 content "application/json" schema') ??
+        getx(responses, '200 schema')
+      if ('get' === method && 'list' == mop.name) {
+        fieldSets = getx(responses, '201 content "application/json" schema items') ??
+          getx(responses, '201 schema items')
+      }
+      else if ('put' === method && null == fieldSets) {
+        fieldSets = getx(responses, '201 content "application/json" schema') ??
+          getx(responses, '201 schema')
+      }
+    }
+
+    if (requestBody) {
+      fieldSets = [
+        fieldSets,
+        getx(requestBody, 'content "application/json" schema') ??
+        getx(requestBody, 'schema')
+      ]
+    }
+
+
+    if (fieldSets) {
+      if (Array.isArray(fieldSets.allOf)) {
+        fieldSets = fieldSets.allOf
+      }
+      else if (fieldSets.properties) {
+        fieldSets = [fieldSets]
       }
     }
+
+    each(fieldSets, (fieldSet: any) => {
+      each(fieldSet?.properties, (property: any) => {
+        fielddefs.push(property)
+      })
+    })
   }
 
-  return fieldCount
+  return fielddefs
 }
 
 
-// Resovles a heuristic "primary" type which subsumes the more detailed type.
-// The primary type is only: string, number, boolean, null, object, array
-function resolveFieldType(entity: any, field: any, property: any) {
-  const ptt = typeof property.type
+function mergeField(
+  ment: ModelEntity,
+  mop: ModelOp,
+  malt: ModelAlt,
+  def: any,
+  exisingField: ModelField,
+  newField: ModelField
+) {
 
-  if ('string' === ptt) {
-    field.type = property.type
-  }
-  else if (Array.isArray(property.type)) {
-    field.type =
-      (property.type.filter((t: string) => 'null' != t).sort()[0]) ||
-      property.type[0] ||
-      'string'
-    field.typelist = property.type
-  }
-  else if ('undefined' === ptt && null != property.enum) {
-    field.type = 'string'
-    field.enum = property.enum
-  }
-  else {
-    throw new Error(
-      `APIDEF: Unsupported property type: ${property.type} (${entity.name}.${field.name})`)
+  if (newField.req !== exisingField.req) {
+    exisingField.op[mop.name] = {
+      req: newField.req,
+      type: newField.type,
+    }
   }
+
+  return exisingField
 }
 
 
 export {
-  fieldTransform
+  fieldTransform,
 }
-