@voxgig/sdkgen 0.14.0 → 0.16.0

package/src/action/target.ts

@@ -0,0 +1,127 @@
+
+import {
+  Jostraca,
+  Project,
+  File,
+  Folder,
+  Content,
+  Copy,
+  cmp,
+  each,
+} from 'jostraca'
+
+
+import { SdkGenError } from '../utility'
+
+
+const CMD_MAP: any = {
+  add: cmd_target_add
+}
+
+async function action_target(args: any[], ctx: any) {
+
+  const cmdname = args[1]
+
+  const cmd = CMD_MAP[cmdname]
+
+  if (null == cmd) {
+    throw new SdkGenError('Unknown target cmd: ' + cmdname)
+  }
+
+  await cmd(args, ctx)
+}
+
+
+async function cmd_target_add(args: any[], ctx: any) {
+
+  let targets = args[2]
+  targets = 'string' === typeof targets ? targets.split(',') : targets
+
+  const jostraca = Jostraca()
+
+  const opts = {
+    fs: ctx.fs,
+    folder: ctx.folder,
+    log: ctx.log.child({ cmp: 'jostraca' }),
+    meta: { model: ctx.model, tree: ctx.tree }
+  }
+
+  await jostraca.generate(opts, () => TargetRoot({ targets }))
+
+}
+
+
+const TargetRoot = cmp(function TargetRoot(props: any) {
+  const { ctx$, targets } = props
+
+  // TODO: model should be a top level ctx property
+  ctx$.model = ctx$.meta.model
+
+  // console.log('MODEL')
+  // console.dir(ctx$.model, { depth: null })
+
+  Project({}, () => {
+    each(targets, (n) => {
+      // TODO: validate target is a-z0-9-_. only
+      const name = n.val$
+
+      Folder({ name: 'model/target' }, () => {
+        Copy({
+          from: 'node_modules/@voxgig/sdkgen/project/generate/model/target/' + name + '.jsonic',
+          // exclude: true
+        })
+      })
+
+      Folder({ name: 'src/cmp/' + name }, () => {
+        Copy({
+          from: 'node_modules/@voxgig/sdkgen/project/generate/src/cmp/' + name,
+          // exclude: true
+        })
+      })
+
+      Folder({ name: 'tm/' + name }, () => {
+        Copy({
+          from: 'node_modules/@voxgig/sdkgen/project/generate/tm/' + name,
+          exclude: [/src\/feature/]
+        })
+      })
+
+
+    })
+  })
+
+  modifyModel({
+    targets,
+    model: ctx$.meta.model,
+    tree: ctx$.meta.tree,
+    fs: ctx$.fs
+  })
+
+})
+
+
+async function modifyModel({ targets, model, tree, fs }: any) {
+  // TODO: This is a kludge.
+  // Aontu should provide option for as-is AST so that can be used
+  // to find injection point more reliably
+
+  const path = tree.url
+  let src = fs().readFileSync(path, 'utf8')
+
+  // Inject target file references into model
+  targets.sort().map((target: string) => {
+    const lineRE =
+      new RegExp(`@"target/${target}.jsonic"`)
+    if (!src.match(lineRE)) {
+      src = src.replace(/(main:\s+sdk:\s+target:\s+\{\s*\}\n)/, '$1' +
+        `@"target/${target}.jsonic"\n`)
+    }
+  })
+
+  fs().writeFileSync(path, src)
+}
+
+
+export {
+  action_target
+}

package/src/cmp/Entity.ts

@@ -1,14 +1,16 @@
 
-import { cmp } from 'jostraca'
+import {
+  cmp,
+} from 'jostraca'
 
 import { requirePath } from '../utility'
 
 
 const Entity = cmp(function Entity(props: any) {
-  const { build, entity, ctx$ } = props
+  const { target, entity, ctx$ } = props
 
-  const Entity_sdk = requirePath(ctx$, `./${build.name}/Entity_${build.name}`)
-  Entity_sdk['Entity']({ build, entity })
+  const Entity_sdk = requirePath(ctx$, `./cmp/${target.name}/Entity_${target.name}`)
+  Entity_sdk['Entity']({ target, entity })
 })
 
 

package/src/cmp/Feature.ts

@@ -5,10 +5,17 @@ import { resolvePath } from '../utility'
 
 
 const Feature = cmp(function Feature(props: any) {
-  const { build, feature, ctx$ } = props
-
-  Folder({ name: 'src/' + feature.name }, () => {
-    Copy({ from: 'feature/' + feature.name + '/' + build.name })
+  const { target, feature, ctx$ } = props
+
+  Folder({ name: 'src/feature/' + feature.name }, () => {
+    // TODO: Copy should just warn if from not found
+    Copy({
+      from: 'tm/' + target.name + '/src/feature/' + feature.name,
+      replace: {
+        FEATURE_VERSION: feature.version,
+        FEATURE_Name: feature.Name,
+      }
+    })
   })
 
 })

package/src/cmp/FeatureHook.ts

@@ -0,0 +1,23 @@
+
+import { each, cmp, names, Content } from 'jostraca'
+
+
+const FeatureHook = cmp(function FeatureHook(props: any, children: any) {
+  const { ctx$: { model } } = props
+
+  const { feature } = model.main.sdk
+
+  const hook: any = {}
+  names(hook, props.name)
+
+  // TODO: much better error reporting for invalid feature hook names
+  each(feature)
+    // .map(feature => (console.log(props.name, feature), feature))
+    .filter(feature => feature.active && feature.hook[props.name].active)
+    .map(feature => each(children, { call: true, args: feature }))
+})
+
+
+export {
+  FeatureHook
+}

package/src/cmp/Main.ts

@@ -1,19 +1,27 @@
 
-import { cmp, Copy } from 'jostraca'
+import { cmp, Copy, Folder } from 'jostraca'
 
 import { resolvePath } from '../utility'
 
 
 const Main = cmp(function Main(props: any) {
-  const { build, ctx$ } = props
+  const { target, ctx$ } = props
   const { model } = ctx$
 
-  const Main_sdk = require(resolvePath(ctx$, `${build.name}/Main_${build.name}`))
+  const Main_sdk = require(resolvePath(ctx$, `cmp/${target.name}/Main_${target.name}`))
 
-  Main_sdk['Main']({ model, build })
+  Main_sdk['Main']({ model, target })
 
-  // TODO: make optional via build model
-  Copy({ from: 'tm/' + build.name + '/LICENSE', name: 'LICENSE' })
+  // TODO: make optional via target model
+  Copy({ from: 'tm/' + target.name + '/LICENSE', to: 'LICENSE' })
+
+  Folder({ name: 'src/utility' }, () => {
+    Copy({
+      from: 'tm/' + target.name + '/src/utility',
+      // TODO: make this work for folders
+      // to: target + '/src'
+    })
+  })
 })
 
 

package/src/cmp/Readme.ts

@@ -11,21 +11,21 @@ import { ReadmeEntity } from './ReadmeEntity'
 
 
 const Readme = cmp(function Readme(props: any) {
-  const { build } = props
+  const { target } = props
   const { model } = props.ctx$
 
   File({ name: 'README.md' }, () => {
 
     Content(`
-# ${model.Name} ${build.title} SDK
+# ${model.Name} ${target.title} SDK
 `)
     // Sections
-    ReadmeIntro({ build })
-    ReadmeInstall({ build })
-    ReadmeQuick({ build })
-    ReadmeModel({ build })
-    ReadmeOptions({ build })
-    ReadmeEntity({ build })
+    ReadmeIntro({ target })
+    ReadmeInstall({ target })
+    ReadmeQuick({ target })
+    ReadmeModel({ target })
+    ReadmeOptions({ target })
+    ReadmeEntity({ target })
   })
 })
 

package/src/cmp/ReadmeInstall.ts

@@ -6,7 +6,7 @@ import { requirePath } from '../utility'
 
 
 const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
-  const { build, ctx$ } = props
+  const { target, ctx$ } = props
 
   Content(`
 ## Install
@@ -14,10 +14,10 @@ const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
 
   // Optional
   const ReadmeInstall_sdk =
-    requirePath(ctx$, `./${build.name}/ReadmeInstall_${build.name}`, { ignore: true })
+    requirePath(ctx$, `./target/${target.name}/ReadmeInstall_${target.name}`, { ignore: true })
 
   if (ReadmeInstall_sdk) {
-    ReadmeInstall_sdk['ReadmeInstall']({ build })
+    ReadmeInstall_sdk['ReadmeInstall']({ target })
   }
 })
 

package/src/cmp/ReadmeOptions.ts

@@ -3,7 +3,7 @@ import { cmp, each, Content } from 'jostraca'
 
 
 const ReadmeOptions = cmp(function ReadmeOptions(props: any) {
-  const { build } = props
+  const { target } = props
 
   Content(`
 
@@ -11,7 +11,7 @@ const ReadmeOptions = cmp(function ReadmeOptions(props: any) {
 
 `)
 
-  each(build.options)
+  each(target.options)
     .filter((option: any) => option.publish)
     .map((option: any) => {
       Content(`

package/src/cmp/ReadmeQuick.ts

@@ -5,7 +5,7 @@ import { requirePath } from '../utility'
 
 
 const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
-  const { build, ctx$ } = props
+  const { target, ctx$ } = props
 
   Content(`
 ## Quick Start
@@ -13,10 +13,10 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
 `)
 
   const ReadmeQuick_sdk =
-    requirePath(ctx$, `./${build.name}/ReadmeQuick_${build.name}`, { ignore: true })
+    requirePath(ctx$, `./target/${target.name}/ReadmeQuick_${target.name}`, { ignore: true })
 
   if (ReadmeQuick_sdk) {
-    ReadmeQuick_sdk['ReadmeQuick']({ build })
+    ReadmeQuick_sdk['ReadmeQuick']({ target })
   }
 })
 

package/src/sdkgen.ts

@@ -2,16 +2,13 @@
 
 import * as Fs from 'node:fs'
 
-
-import * as JostracaModule from 'jostraca'
-
-// import Pino from 'pino'
-// import PinoPretty from 'pino-pretty'
-
 import { prettyPino, Pino } from '@voxgig/util'
 
-import { ApiDef } from '@voxgig/apidef'
+import { Jsonic } from 'jsonic'
+import * as JostracaModule from 'jostraca'
+import { Aontu, Context } from 'aontu'
 
+import { SdkGenError } from './utility'
 
 import { Main } from './cmp/Main'
 import { Entity } from './cmp/Entity'
@@ -20,8 +17,11 @@ import { Readme } from './cmp/Readme'
 import { ReadmeInstall } from './cmp/ReadmeInstall'
 import { ReadmeOptions } from './cmp/ReadmeOptions'
 import { ReadmeEntity } from './cmp/ReadmeEntity'
+import { FeatureHook } from './cmp/FeatureHook'
+
+import { action_target } from './action/target'
+import { action_feature } from './action/feature'
 
-import { PrepareOpenAPI } from './prepare-openapi'
 
 
 type SdkGenOptions = {
@@ -44,18 +44,20 @@ type SdkGenOptions = {
 const { Jostraca } = JostracaModule
 
 
+const ACTION_MAP: any = {
+  target: action_target,
+  feature: action_feature,
+}
+
+
 function SdkGen(opts: SdkGenOptions) {
   const fs = opts.fs || Fs
-  const folder = opts.folder || '.'
-  // const def = opts.def || 'def.yml'
+  const folder = opts.folder || '../'
   const jostraca = Jostraca()
 
   const pino = prettyPino('sdkgen', opts)
-
   const log = pino.child({ cmp: 'sdkgen' })
 
-  // console.log('SDKGEN OPTS', opts)
-
 
   async function generate(spec: any) {
     const start = Date.now()
@@ -72,28 +74,107 @@ function SdkGen(opts: SdkGenOptions) {
       Root = rootModule.Root
     }
 
-    /*
-    if (await prepare(spec, { fs, folder, def })) {
-      return
+    const jopts = {
+      fs: () => fs,
+      folder,
+      log: log.child({ cmp: 'jostraca' }),
+      meta: { spec },
+      debug: opts.debug,
     }
-    */
-
-    const opts = { fs, folder, log: log.child({ cmp: 'jostraca' }), meta: { spec } }
 
-    await jostraca.generate(opts, () => Root({ model }))
+    await jostraca.generate(jopts, () => Root({ model }))
 
     log.info({ point: 'generate-end' })
+
+    return { ok: true, name: 'sdkgen' }
   }
 
 
-  async function prepare(spec: any, ctx: any) {
-    return await PrepareOpenAPI(spec, ctx)
+  async function action(args: string[]) {
+    const pargs = args.map(arg => Jsonic(arg))
+
+    const actname = args[0]
+    const action = ACTION_MAP[actname]
+
+    if (null == action) {
+      throw new SdkGenError('Unknown action: ' + actname)
+    }
+
+
+    const { model, tree } = resolveModel()
+
+
+    const ctx = {
+      fs: () => fs,
+      log,
+      folder: '.', // The `generate` folder,
+      model,
+      tree,
+    }
+
+    await action(pargs, ctx)
+  }
+
+
+  function resolveModel() {
+    const path = './model/sdk.jsonic'
+    const aopts = { path }
+    const src = fs.readFileSync(path, 'utf8')
+
+    const tree = Aontu(src, aopts)
+    const hasErr = tree.err && 0 < tree.err.length
+
+    if (hasErr) {
+      for (let serr of tree.err) {
+        let err: any = new SdkGenError('Model Error: ' + serr.msg)
+        err.cause$ = [serr]
+
+        if ('syntax' === serr.why) {
+          err.uxmsg$ = true
+        }
+
+        // log.error({ fail: 'parse', point: 'guide-parse', file: path, err })
+
+
+        err.rooterrs$ = tree.err
+        throw err
+      }
+    }
+
+    let genctx = new Context({ root: tree })
+    const model = tree.gen(genctx)
+
+    // TODO: collect all errors
+    if (genctx.err && 0 < genctx.err.length) {
+      const err: any = new SdkGenError('Model 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
+    }
+
+    // TODO: FIX: This is a hack to set the correct src file
+    // aontu bug: url is empty
+    tree.url = path
+
+
+    model.const = { name: model.name }
+
+    names(model.const, model.name)
+
+    model.const.year = new Date().getFullYear()
+
+    return {
+      model,
+      tree,
+    }
   }
 
 
   return {
     pino,
     generate,
+    action,
   }
 
 }
@@ -101,6 +182,7 @@ function SdkGen(opts: SdkGenOptions) {
 
 SdkGen.makeBuild = async function(opts: SdkGenOptions) {
   let sdkgen: any = undefined
+  // let apidef: any = undefined
 
   const config = {
     root: opts.root,
@@ -115,21 +197,12 @@ SdkGen.makeBuild = async function(opts: SdkGenOptions) {
       sdkgen = SdkGen({
         ...opts,
         pino: build.log,
+        debug: build.spec.debug,
       })
-
-      const apidef = ApiDef({
-        pino: build.log,
-      })
-
-      if (true === ctx.watch) {
-        await apidef.watch(config)
-      }
-      else {
-        await apidef.generate(config)
-      }
     }
 
-    await sdkgen.generate({ model, build, config })
+    // await apidef.generate({ model, build, config })
+    return await sdkgen.generate({ model, build, config })
   }
 }
 
@@ -191,6 +264,11 @@ export const cmap: (o: any, p: any) => any = JostracaModule.cmap
 export const vmap: (o: any, p: any) => any = JostracaModule.vmap
 export const get: (root: any, path: string | string[]) => any = JostracaModule.get
 export const getx: (root: any, path: string | string[]) => any = JostracaModule.getx
+export const template: (root: any, path: string | string[]) => any = JostracaModule.template
+
+export const deep: (...args: any[]) => any = JostracaModule.deep
+export const omap: (...args: any[]) => any = JostracaModule.omap
+
 
 export const Project: Component = JostracaModule.Project
 export const Folder: Component = JostracaModule.Folder
@@ -199,6 +277,9 @@ export const Content: Component = JostracaModule.Content
 export const Copy: Component = JostracaModule.Copy
 export const Fragment: Component = JostracaModule.Fragment
 export const Inject: Component = JostracaModule.Inject
+export const Line: Component = JostracaModule.Line
+export const Slot: Component = JostracaModule.Slot
+export const List: Component = JostracaModule.List
 
 
 export {
@@ -209,6 +290,7 @@ export {
   ReadmeInstall,
   ReadmeOptions,
   ReadmeEntity,
+  FeatureHook,
 
   Jostraca,
   SdkGen,

package/src/utility.ts

@@ -1,9 +1,11 @@
 
 import Path from 'node:path'
 
+// TODO: move to @voxgig/util as duplicated with @voxgig/sdkgen
 
 const resolvePath = (ctx$: any, path: string): any => {
-  const fullpath = Path.join(ctx$.folder, '..', 'dist', path)
+  // console.log('RP', ctx$.folder)
+  const fullpath = Path.join(ctx$.folder, 'generate', 'dist', path)
   return fullpath
 }
 
@@ -26,8 +28,16 @@ const requirePath = (ctx$: any, path: string, flags?: { ignore?: boolean }): any
 }
 
 
+class SdkGenError extends Error {
+  constructor(...args: any[]) {
+    super(...args)
+    this.name = 'SdkGenError'
+  }
+}
+
 
 export {
   resolvePath,
   requirePath,
+  SdkGenError,
 }

package/src/prepare-openapi.ts

@@ -1,59 +0,0 @@
-
-import * as Fs from 'node:fs'
-
-import { each } from 'jostraca'
-
-import { bundleFromString, createConfig } from '@redocly/openapi-core'
-
-
-async function PrepareOpenAPI(inspec: any, ctx: any) {
-
-  // TODO: avoid rebuilding if unchanged
-
-  // const source = Fs.readFileSync(ctx.def, 'utf8')
-
-  // const config = await createConfig({})
-  // const bundle = await bundleFromString({
-  //   source,
-  //   config,
-  //   dereference: true,
-  // })
-
-  // // console.log('BUNDLE', bundle)
-
-  // Fs.writeFileSync(
-  //   ctx.folder + '/../model/def.jsonic',
-  //   JSON.stringify(bundle.bundle.parsed, null, 2)
-  // )
-
-
-  // const spec: any = {}
-
-  // spec.main = {
-  //   sdk: {
-  //     api: {
-  //       // cmap
-  //       /*
-  //               path: each(bundle.bundle.parsed.paths, (path: any) => ({
-  //                 param: {}
-  //                 }))
-  //                 */
-  //     }
-  //   }
-  // }
-
-
-  // Fs.writeFileSync(
-  //   ctx.folder + '/../model/spec.jsonic',
-  //   JSON.stringify(spec, null, 2)
-  // )
-
-
-  return false
-}
-
-
-
-export {
-  PrepareOpenAPI
-}