@voxgig/apidef 2.0.0 → 2.1.0

package/src/parse.ts

@@ -2,6 +2,10 @@
 
 import { bundleFromString, createConfig } from '@redocly/openapi-core'
 
+import { each, snakify } from 'jostraca'
+
+
+import { depluralize } from './utility'
 
 
 // Parse an API definition source into a JSON sructure.
@@ -16,12 +20,51 @@ async function parse(kind: string, source: any, meta?: any) {
 
 
 async function parseOpenAPI(source: any, meta?: any) {
-  const config = await createConfig(meta?.config || {})
-  let bundle
+  const base = meta?.config || {}
+  const config: any = await createConfig(base)
 
-  bundle = await bundleFromString({
+  // First pass: parse without dereferencing to preserve $refs
+  const bundleWithRefs = await bundleFromString({
     source,
     config,
+    dereference: false,
+  })
+
+  // Walk the tree and add x-ref properties
+  const seen = new WeakSet()
+  let refCount = 0
+
+  function addXRefs(obj: any, path: string = '') {
+    if (!obj || typeof obj !== 'object' || seen.has(obj)) return
+    seen.add(obj)
+
+    if (Array.isArray(obj)) {
+      obj.forEach((item, index) => addXRefs(item, `${path}[${index}]`))
+    } else {
+      // Check for $ref property
+      if (obj.$ref && typeof obj.$ref === 'string') {
+        obj['x-ref'] = obj.$ref
+        refCount++
+      }
+
+      // Recursively process all properties
+      for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object') {
+          addXRefs(value, path ? `${path}.${key}` : key)
+        }
+      }
+    }
+  }
+
+  addXRefs(bundleWithRefs.bundle.parsed)
+
+  // Serialize back to string with x-refs preserved
+  const sourceWithXRefs = JSON.stringify(bundleWithRefs.bundle.parsed)
+
+  // Second pass: parse with dereferencing
+  const bundle = await bundleFromString({
+    source: sourceWithXRefs,
+    config,
     dereference: true,
   })
 
@@ -31,6 +74,65 @@ async function parseOpenAPI(source: any, meta?: any) {
 }
 
 
+
+
+
+
+
+// Make consistent changes to support semantic entities.
+function rewrite(def: any) {
+  const paths = def.paths
+  each(paths, (path) => {
+    each(path.parameters, (param: any) => {
+
+      let new_param = param.name
+      let new_path = path.key$
+
+      // Rename param if nane is "id", and not the final param.
+      // Rewrite /foo/{id}/bar as /foo/{foo_id}/bar.
+      // Avoids ambiguity with bar id.
+      if (param.name.match(/^id$/i)) {
+        let m = path.key$.match(/\/([^\/]+)\/{id\}\/[^\/]/)
+
+        if (m) {
+          const parent = depluralize(snakify(m[1]))
+          new_param = `${parent}_id`
+          new_path = path.key$.replace('{id}', '{' + new_param + '}')
+        }
+      }
+      else {
+        new_param = depluralize(snakify(param.name))
+        new_path = path.key$.replace('{' + param.name + '}', '{' + new_param + '}')
+      }
+
+      let pathdef = paths[path.key$]
+      delete paths[path.key$]
+
+      paths[new_path] = pathdef
+      path.key$ = new_path
+
+      param.name = new_param
+    })
+  })
+
+
+  sortkeys(def, 'paths')
+  sortkeys(def, 'components')
+
+  return def
+}
+
+
+function sortkeys(obj: any, prop: string) {
+  const sorted: any = {}
+  const sorted_keys = Object.keys(obj[prop]).sort()
+  for (let sk of sorted_keys) {
+    sorted[sk] = obj[prop][sk]
+  }
+  obj[prop] = sorted
+}
+
 export {
-  parse
+  parse,
+  rewrite,
 }

package/src/transform/clean.ts

@@ -0,0 +1,28 @@
+
+import { each, getx } from 'jostraca'
+
+import type { TransformResult } from '../transform'
+
+import { walk } from '@voxgig/struct'
+
+
+
+const cleanTransform = async function(
+  ctx: any,
+): Promise<TransformResult> {
+  const { apimodel } = ctx
+
+  walk(apimodel, (k: any, v: any) => {
+    if ('string' === typeof k && k.includes('$')) {
+      return undefined
+    }
+    return v
+  })
+
+  return { ok: true, msg: 'clean' }
+}
+
+
+export {
+  cleanTransform
+}

package/src/transform/entity.ts

@@ -1,11 +1,13 @@
 
 
-import { each } from 'jostraca'
+import { each, snakify } from 'jostraca'
 
 import type { TransformResult, Transform } from '../transform'
 
 import { fixName } from '../transform'
 
+import { depluralize } from '../utility'
+
 
 const entityTransform: Transform = async function(
   ctx: any,
@@ -30,12 +32,16 @@ const entityTransform: Transform = async function(
       id: {
         name: 'id',
         field: 'id',
-      }
+      },
+      ancestors: []
     }
 
     fixName(entityModel, guideEntity.key$)
 
-    each(guideEntity.path, (guidePath: any) => {
+    let ancestors: string[] = []
+    let ancestorsDone = false
+
+    each(guideEntity.path, (guidePath: any, pathStr: string) => {
       const path = guidePath.key$
       const pathdef = def.paths[path]
 
@@ -50,8 +56,25 @@ const entityTransform: Transform = async function(
         .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
+
     msg += guideEntity.name + ' '
   })
 

package/src/transform/field.ts

@@ -69,7 +69,8 @@ function fieldbuild(
       field.name = property.key$
       fixName(field, field.name)
 
-      field.type = property.type
+      // field.type = property.type
+      resolveFieldType(entityModel, field, property)
       fixName(field, field.type, 'type')
 
       field.short = property.description
@@ -93,6 +94,31 @@ function fieldbuild(
 }
 
 
+// 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
+
+  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})`)
+  }
+}
+
 
 export {
   fieldTransform