@voxgig/apidef 0.2.0 → 1.0.0

package/src/apidef.ts

@@ -1,64 +1,127 @@
-/* Copyright (c) 2024 Richard Rodger, MIT License */
+/* Copyright (c) 2024 Voxgig, MIT License */
 
 import * as Fs from 'node:fs'
-
 import Path from 'node:path'
 
 
 import { bundleFromString, createConfig } from '@redocly/openapi-core'
-
 import { FSWatcher } from 'chokidar'
-
 import { Aontu, Context } from 'aontu'
 
-import { getx, each, camelify } from 'jostraca'
+import { prettyPino, Pino } from '@voxgig/util'
+
+
+import {
+  resolveTransforms,
+  processTransforms,
+  fixName,
+} from './transform'
 
 
 type ApiDefOptions = {
   fs?: any
+  pino?: ReturnType<typeof Pino>
+  debug?: boolean | string
 }
 
 
+type ApiDefSpec = {
+  def: string
+  model: string,
+  kind: string,
+  meta: Record<string, any>,
+}
 
 
 function ApiDef(opts: ApiDefOptions = {}) {
   const fs = opts.fs || Fs
+  const pino = prettyPino('apidef', opts)
+
+  const log = pino.child({ cmp: 'apidef' })
 
 
   async function watch(spec: any) {
+    log.info({ point: 'watch-start' })
+    log.debug({ point: 'watch-spec', spec })
+
     await generate(spec)
 
     const fsw = new FSWatcher()
 
     fsw.on('change', (...args: any[]) => {
-      // console.log('APIDEF CHANGE', args)
+      log.trace({ watch: 'change', file: args[0] })
       generate(spec)
     })
 
-    // console.log('APIDEF-WATCH', spec.def)
+    log.trace({ watch: 'add', what: 'def', file: spec.def })
     fsw.add(spec.def)
 
-    // console.log('APIDEF-WATCH', spec.guide)
+    log.trace({ watch: 'add', what: 'guide', file: spec.guilde })
     fsw.add(spec.guide)
   }
 
 
-  async function generate(spec: any) {
-    // console.log('APIDEF.generate')
+  async function generate(spec: ApiDefSpec) {
+    const start = Date.now()
+
+    // TODO: validate spec
+
+    const defpath = Path.normalize(spec.def)
+
+    log.info({ point: 'generate-start', note: 'defpath', defpath, start })
+    log.debug({ point: 'generate-spec', spec })
+
+    // TODO: Validate spec
+    const ctx = {
+      log,
+      spec,
+      guide: {},
+      opts,
+      util: { fixName },
+      defpath: Path.dirname(defpath)
+    }
+
+
 
     const guide = await resolveGuide(spec, opts)
-    const transform = resolveTranform(spec, guide, opts)
 
-    const source = fs.readFileSync(spec.def, 'utf8')
+    if (null == guide) {
+      return
+    }
+
+
+    log.debug({ point: 'guide', guide })
+
+    ctx.guide = guide
+    const transformSpec = await resolveTransforms(ctx)
+    log.debug({ point: 'transform', spec: transformSpec })
+
+
+    let source
+    try {
+      source = fs.readFileSync(spec.def, 'utf8')
+    }
+    catch (err: any) {
+      log.error({ read: 'fail', what: 'def', file: defpath, err })
+      throw err
+    }
 
-    const modelBasePath = Path.dirname(spec.model)
 
     const config = await createConfig({})
-    const bundle = await bundleFromString({
-      source,
-      config,
-      dereference: true,
-    })
+    let bundle
+
+    try {
+      bundle = await bundleFromString({
+        source,
+        config,
+        dereference: true,
+      })
+    }
+    catch (err: any) {
+      log.error({ parse: 'fail', what: 'openapi', file: defpath, err })
+      throw err
+    }
+
 
     const model = {
       main: {
@@ -71,11 +134,18 @@ function ApiDef(opts: ApiDefOptions = {}) {
 
     try {
       const def = bundle.bundle.parsed
-      // console.dir(def, { depth: null })
-      transform(def, model)
+      const processResult = await processTransforms(ctx, transformSpec, model, def)
+
+      if (!processResult.ok) {
+        log.error({ process: 'fail', what: 'transform', result: processResult })
+        throw new Error('Transform failed: ' + processResult.msg)
+      }
+      else {
+        log.debug({ process: 'result', what: 'transform', result: processResult })
+      }
     }
     catch (err: any) {
-      console.log('APIDEF ERROR', err)
+      log.error({ process: 'fail', what: 'transform', err })
       throw err
     }
 
@@ -83,34 +153,19 @@ function ApiDef(opts: ApiDefOptions = {}) {
     let modelSrc = JSON.stringify(modelapi, null, 2)
     modelSrc = modelSrc.substring(1, modelSrc.length - 1)
 
-    fs.writeFileSync(
-      spec.model,
-      modelSrc
-    )
+    writeChanged('api-model', spec.model, modelSrc)
 
 
+    const modelBasePath = Path.dirname(spec.model)
     const defFilePath = Path.join(modelBasePath, 'def.jsonic')
 
     const modelDef = { main: { def: model.main.def } }
     let modelDefSrc = JSON.stringify(modelDef, null, 2)
     modelDefSrc = modelDefSrc.substring(1, modelDefSrc.length - 1)
 
-    let existingSrc: string = ''
-    if (fs.existsSync(defFilePath)) {
-      existingSrc = fs.readFileSync(defFilePath, 'utf8')
-    }
-
-    let writeModelDef = existingSrc !== modelDefSrc
-    // console.log('APIDEF', writeModelDef)
-
-    // Only write the model def if it has changed
-    if (writeModelDef) {
-      fs.writeFileSync(
-        defFilePath,
-        modelDefSrc
-      )
-    }
+    writeChanged('def-model', defFilePath, modelDefSrc)
 
+    log.info({ point: 'generate-end', note: 'success', break: true })
 
     return {
       ok: true,
@@ -119,6 +174,47 @@ function ApiDef(opts: ApiDefOptions = {}) {
   }
 
 
+
+  function writeChanged(what: string, path: string, content: string) {
+    let exists = false
+    let changed = false
+    let action = ''
+    try {
+      let existingContent: string = ''
+      path = Path.normalize(path)
+
+      exists = fs.existsSync(path)
+
+      if (exists) {
+        action = 'read'
+        existingContent = fs.readFileSync(path, 'utf8')
+      }
+
+      changed = existingContent !== content
+
+      log.info({
+        point: 'write-' + what,
+        note: 'changed,file',
+        write: 'file', what, skip: !changed, exists, changed,
+        contentLength: content.length, file: path
+      })
+
+      if (changed) {
+        action = 'write'
+        fs.writeFileSync(path, content)
+      }
+    }
+    catch (err: any) {
+      log.error({
+        fail: action, what, file: path, exists, changed,
+        contentLength: content.length, err
+      })
+      throw err
+    }
+  }
+
+
+
   async function resolveGuide(spec: any, _opts: any) {
     if (null == spec.guide) {
       spec.guide = spec.def + '-guide.jsonic'
@@ -127,34 +223,70 @@ function ApiDef(opts: ApiDefOptions = {}) {
     const path = Path.normalize(spec.guide)
     let src: string
 
-    // console.log('APIDEF resolveGuide', path)
+    let action = ''
+    let exists = false
+    try {
 
-    if (fs.existsSync(path)) {
-      src = fs.readFileSync(path, 'utf8')
-    }
-    else {
-      src = `
+      action = 'exists'
+      let exists = fs.existsSync(path)
+
+      log.debug({ read: 'file', what: 'guide', file: path, exists })
+
+      if (exists) {
+        action = 'read'
+        src = fs.readFileSync(path, 'utf8')
+      }
+      else {
+        src = `
 # API Specification Transform Guide
 
-@"node_modules/@voxgig/apidef/model/guide.jsonic"
+@"@voxgig/apidef/model/guide.jsonic"
 
 guide: entity: {
 
 }
 
+guide: control: transform: openapi: order: \`
+  top,
+  entity,
+  operation,
+  field,
+  manual,
+  \`
+
 `
-      fs.writeFileSync(path, src)
+        action = 'write'
+        fs.writeFileSync(path, src)
+      }
+    }
+    catch (err: any) {
+      log.error({ fail: action, what: 'guide', file: path, exists, err })
+      throw err
     }
 
-    const aopts = {}
+    const aopts = { path }
     const root = Aontu(src, aopts)
     const hasErr = root.err && 0 < root.err.length
 
-    // TODO: collect all errors
     if (hasErr) {
-      // console.log(root.err)
-      // throw new Error(root.err[0])
-      throw root.err[0].err
+      for (let serr of root.err) {
+        let err: any = new Error('Guide model: ' + serr.msg)
+        err.cause$ = [serr]
+
+        if ('syntax' === serr.why) {
+          err.uxmsg$ = true
+        }
+
+        log.error({ fail: 'parse', point: 'guide-parse', file: path, err })
+
+        if (err.uxmsg$) {
+          return
+        }
+        else {
+          err.rooterrs$ = root.err
+          throw err
+        }
+      }
     }
 
     let genctx = new Context({ root })
@@ -162,27 +294,19 @@ guide: entity: {
 
     // TODO: collect all errors
     if (genctx.err && 0 < genctx.err.length) {
-      // console.log(genctx.err)
-      throw new Error(JSON.stringify(genctx.err[0]))
+      const err: any = new Error('Guide build error:\n' +
+        (genctx.err.map((pe: any) => pe.msg)).join('\n'))
+      log.error({ fail: 'build', what: 'guide', file: path, err })
+      err.errs = () => genctx.err
+      throw err
     }
 
-    // console.log('GUIDE')
-    // console.dir(guide, { depth: null })
-
     const pathParts = Path.parse(path)
     spec.guideModelPath = Path.join(pathParts.dir, pathParts.name + '.json')
 
     const updatedSrc = JSON.stringify(guide, null, 2)
 
-    // console.log('APIDEF resolveGuide write', spec.guideModelPath, src !== updatedSrc)
-    let existingSrc = ''
-    if (fs.existsSync(spec.guideModelPath)) {
-      existingSrc = fs.readFileSync(spec.guideModelPath, 'utf8')
-    }
-
-    if (existingSrc !== updatedSrc) {
-      fs.writeFileSync(spec.guideModelPath, updatedSrc)
-    }
+    writeChanged('guide-model', spec.guideModelPath, updatedSrc)
 
     return guide
   }
@@ -197,195 +321,6 @@ guide: entity: {
 
 
 
-
-function resolveTranform(spec: any, guide: any, opts: any) {
-  return makeOpenAPITransform(spec, guide, opts)
-}
-
-
-function extractFields(properties: any) {
-  const fieldMap = each(properties)
-    .reduce((a: any, p: any) => (a[p.key$] =
-      { name: p.key$, kind: camelify(p.type) }, a), {})
-  return fieldMap
-}
-
-
-function fixName(base: any, name: string, prop = 'name') {
-  base[prop.toLowerCase()] = name.toLowerCase()
-  base[camelify(prop)] = camelify(name)
-  base[prop.toUpperCase()] = name.toUpperCase()
-}
-
-
-function makeOpenAPITransform(spec: any, guideModel: any, opts: any) {
-
-  const paramBuilder = (paramMap: any, paramDef: any,
-    entityModel: any, pathdef: any,
-    op: any, path: any, entity: any, model: any) => {
-
-    paramMap[paramDef.name] = {
-      required: paramDef.required
-    }
-    fixName(paramMap[paramDef.name], paramDef.name)
-
-    const type = paramDef.schema ? paramDef.schema.type : paramDef.type
-    fixName(paramMap[paramDef.name], type, 'type')
-  }
-
-
-  const queryBuilder = (queryMap: any, queryDef: any,
-    entityModel: any, pathdef: any,
-    op: any, path: any, entity: any, model: 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')
-  }
-
-
-  const opBuilder: any = {
-    any: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      const em = entityModel.op[op.key$] = {
-        path: path.key$,
-        method: op.val$,
-        param: {},
-        query: {},
-      }
-      fixName(em, op.key$)
-
-      // Params are in the path
-      if (0 < path.params.length) {
-        let params = getx(pathdef[op.val$], '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)
-        }
-      }
-
-      // Queries are after the ?
-      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)
-      }
-
-      return em
-    },
-
-
-    list: (entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any) => {
-      return opBuilder.any(entityModel, pathdef, op, path, entity, model)
-    },
-
-    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)
-    },
-
-    save: (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 fieldbuild(
-    entityModel: any, pathdef: any, op: any, path: any, entity: any, model: any
-  ) {
-    // console.log(pathdef)
-
-    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]
-      }
-    }
-
-    each(fieldSets, (fieldSet: any) => {
-      each(fieldSet.properties, (property: any) => {
-        // console.log(property)
-
-        const field =
-          (entityModel.field[property.key$] = entityModel.field[property.key$] || {})
-
-        field.name = property.key$
-        fixName(field, field.name)
-
-        field.type = property.type
-        fixName(field, field.type, 'type')
-
-        field.short = property.description
-      })
-    })
-  }
-
-
-  return function OpenAPITransform(def: any, model: any) {
-    fixName(model.main.api, spec.meta.name)
-
-    // console.log('OpenAPITransform', guideModel)
-
-    model.main.def.desc = def.info.description
-
-
-    each(guideModel.guide.entity, (entity: any) => {
-      // console.log('ENTITY', entity)
-
-      const entityModel: any = model.main.api.entity[entity.key$] = {
-        op: {},
-        field: {},
-        cmd: {},
-      }
-
-      fixName(entityModel, entity.key$)
-
-      each(entity.path, (path: any) => {
-        const pathdef = def.paths[path.key$]
-
-        if (null == pathdef) {
-          throw new Error('APIDEF: path not found in OpenAPI: ' + path.key$ +
-            ' (entity: ' + entity.name + ')')
-        }
-
-        path.parts = path.key$.split('/')
-        path.params = path.parts
-          .filter((p: string) => p.startsWith('{'))
-          .map((p: string) => p.substring(1, p.length - 1))
-
-        // console.log('ENTITY-PATH', entity, path)
-
-        each(path.op, (op: any) => {
-          const opbuild = opBuilder[op.key$]
-
-          if (opbuild) {
-            opbuild(entityModel, pathdef, op, path, entity, model)
-          }
-
-          if ('load' === op.key$) {
-            fieldbuild(entityModel, pathdef, op, path, entity, model)
-          }
-        })
-      })
-    })
-  }
-}
-
-
 export type {
   ApiDefOptions,
 }

package/src/transform/entity.ts

@@ -0,0 +1,54 @@
+
+
+import { each } from 'jostraca'
+
+import type { TransformCtx, TransformSpec } from '../transform'
+
+import { fixName } from '../transform'
+
+
+
+async function entityTransform(ctx: TransformCtx, tspec: TransformSpec, model: any, def: any) {
+  const { guide: { guide } } = ctx
+  let msg = ''
+
+  each(guide.entity, (guideEntity: any) => {
+
+    const entityModel: any = model.main.api.entity[guideEntity.key$] = {
+      op: {},
+      field: {},
+      cmd: {},
+      id: {
+        name: 'id',
+        field: 'id',
+      }
+    }
+
+    fixName(entityModel, guideEntity.key$)
+
+    each(guideEntity.path, (guidePath: any) => {
+      const pathdef = def.paths[guidePath.key$]
+
+      if (null == pathdef) {
+        throw new Error('APIDEF: path not found in OpenAPI: ' + guidePath.key$ +
+          ' (entity: ' + guideEntity.name + ')')
+      }
+
+      guidePath.parts$ = guidePath.key$.split('/')
+      guidePath.params$ = guidePath.parts$
+        .filter((p: string) => p.startsWith('{'))
+        .map((p: string) => p.substring(1, p.length - 1))
+
+    })
+
+    msg += guideEntity.name + ' '
+
+  })
+
+  return { ok: true, msg }
+}
+
+
+export {
+  entityTransform
+}