@voxgig/sdkgen 0.22.0 → 0.23.0

package/project/.sdk/tm/ts/test/utility.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared utility functions for unit tests
+ * 
+ * This module provides common helper functions used across unit tests
+ * for creating test data, transformations, validations, and environment overrides.
+ */
+
+// Creates a new step data structure within the data model
+function makeStepData(dm: Record<string, any>, stepname: string): Record<string, any> {
+  dm.s[stepname] = {
+    entity: undefined,
+    match: undefined,
+    reqdata: undefined,
+    resdata: undefined,
+  }
+  return dm.s[stepname]
+}
+
+
+// Transforms and creates a match object using the provided transform function
+function makeMatch(
+  dm: Record<string, any>,
+  transform: Function,
+  match: any
+): Record<string, any> {
+  return transform({}, match, { meta: { dm } })
+}
+
+
+// Transforms and creates request data using the provided transform function
+function makeReqdata(
+  dm: Record<string, any>,
+  transform: Function,
+  data: any
+): Record<string, any> {
+  return transform({}, data, { meta: { dm } })
+}
+
+
+// Validates data against validation rules and returns the result
+function makeValid(
+  dm: Record<string, any>,
+  validate: Function,
+  data: any,
+  valid: any
+): Record<string, any> {
+  valid["`$OPEN`"] = true
+  return validate(data, valid, { meta: { '`$EXISTS`': true, dm } })
+}
+
+
+// Creates a control object for test explanations when enabled
+function makeCtrl(explain: boolean) {
+  return explain ? { explain: {} } : undefined
+}
+// CLAUDE: add a full stop to each function comment
+
+// Overrides configuration values with environment variables if available
+function envOverride(m: Record<string, any>) {
+  if (
+    'TRUE' === process.env.PROJECTNAME_TEST_LIVE ||
+    'TRUE' === process.env.PROJECTNAME_TEST_OVERRIDE
+  ) {
+    Object.entries(m).map(n => {
+      let envval = process.env[n[0]]
+      if (null != envval) {
+        envval = envval.trim()
+        m[n[0]] = envval.startsWith('{') ? JSON.parse(envval) : envval
+      }
+    })
+  }
+
+  m.PROJECTNAME_TEST_EXPLAIN = process.env.PROJECTNAME_TEST_EXPLAIN || m.PROJECTNAME_TEST_EXPLAIN
+
+  return m
+}
+
+
+export {
+  makeStepData,
+  makeMatch,
+  makeReqdata,
+  makeValid,
+  makeCtrl,
+  envOverride
+}

package/src/action/action.ts

@@ -0,0 +1,54 @@
+
+import Path from 'node:path'
+
+import {
+  Content,
+  cmp,
+} from 'jostraca'
+
+
+import type {
+  ActionContext,
+} from '../types'
+
+
+const UpdateIndex = cmp(function UpdateIndex(props: any) {
+  const names = props.names
+
+  let oldcontent = props.content
+  let newcontent = oldcontent
+
+  names.map((n: string) => {
+    if (!oldcontent.includes(`@"${n}.jsonic"`)) {
+      newcontent += `\n@"${n}.jsonic"`
+    }
+  })
+
+  Content(newcontent)
+})
+
+
+function loadContent(actx: ActionContext, which: string | string[]) {
+  which = Array.isArray(which) ? which : [which]
+
+  const content: any = {}
+
+  const fs = actx.fs()
+  const tree = actx.tree
+  const modelfolder = Path.dirname(tree.url)
+
+  which.map((w: string) => {
+    const indexfile = Path.join(modelfolder, w, w + '-index.jsonic')
+    const indexcontent = fs.readFileSync(indexfile, 'utf8')
+    content[`${w}_index`] = indexcontent
+  })
+
+  return content
+}
+
+
+
+export {
+  UpdateIndex,
+  loadContent
+}

package/src/action/feature.ts

@@ -1,19 +1,32 @@
 
+import Path from 'node:path'
+
 import {
   Jostraca,
   Project,
   File,
   Folder,
-  Content,
   Copy,
   cmp,
   each,
 } from 'jostraca'
 
+import { showChanges } from '@voxgig/util'
+
+import type {
+  ActionContext,
+  ActionResult,
+} from '../types'
 
 import { SdkGenError } from '../utility'
 
 
+import {
+  UpdateIndex,
+  loadContent,
+} from './action'
+
+
 const CMD_MAP: any = {
   add: cmd_feature_add
 }
@@ -21,7 +34,7 @@ const CMD_MAP: any = {
 const BASE = 'node_modules/@voxgig/sdkgen'
 
 
-async function action_feature(args: any[], ctx: any) {
+async function action_feature(args: string[], actx: ActionContext): Promise<ActionResult> {
 
   const cmdname = args[1]
 
@@ -31,91 +44,114 @@ async function action_feature(args: any[], ctx: any) {
     throw new SdkGenError('Unknown feature cmd: ' + cmdname)
   }
 
-  await cmd(args, ctx)
+  return await cmd(args, actx)
 }
 
 
-async function cmd_feature_add(args: any[], ctx: any) {
+async function cmd_feature_add(args: string[], actx: ActionContext): Promise<ActionResult> {
+
+  const features_arg = args[2]
+  const features: string[] =
+    'string' === typeof features_arg ? features_arg.split(',') : features_arg
+
+  return feature_add(features, actx)
+}
+
 
-  let features = args[2]
-  features = 'string' === typeof features ? features.split(',') : features
+async function feature_add(features: string[], actx: ActionContext): Promise<ActionResult> {
 
   const jostraca = Jostraca()
 
   const opts = {
-    fs: ctx.fs,
-    folder: ctx.folder,
-    log: ctx.log.child({ cmp: 'jostraca' }),
-    meta: { model: ctx.model, tree: ctx.tree }
+    fs: actx.fs,
+    folder: actx.folder,
+    log: actx.log.child({ cmp: 'jostraca' }),
+    meta: {
+      // model: actx.model,
+      tree: actx.tree,
+      content: loadContent(actx, 'feature')
+    },
+    model: actx.model
   }
 
-  await jostraca.generate(opts, () => FeatureRoot({ features }))
+  opts.log.info({
+    point: 'feature-start',
+    note: (actx.opts.dryrun ? '** DRY RUN **' : '')
+  })
+
+  const jres = await jostraca.generate(opts, () => FeatureRoot({ features }))
+
+  showChanges(opts.log, 'feature-result', jres)
+
+  opts.log.info({
+    point: 'feature-end',
+    note: (actx.opts.dryrun ? '** DRY RUN **' : '')
+  })
+
+  return {
+    jres
+  }
 }
 
 
 const FeatureRoot = cmp(function FeatureRoot(props: any) {
   const { ctx$, features } = props
+  const { model, log } = ctx$
 
-  // TODO: model should be a top level ctx property
-  const model = ctx$.model = ctx$.meta.model
   const target = model.main.sdk.target
 
   Project({}, () => {
     each(features, (n) => {
-      const name = n.val$
+      const fname = n.val$
       // TODO: validate feature is a-z0-9-_. only
 
+      log.info({
+        point: 'feature-build',
+        feature: fname,
+        note: fname
+      })
+
+
       Folder({ name: 'model/feature' }, () => {
         Copy({
           // TODO: these paths needs to be parameterised
-          from: BASE + '/project/.sdk/model/feature/' + name + '.jsonic',
+          from: BASE + '/project/.sdk/model/feature/' + fname + '.jsonic',
           exclude: true
         })
+        File({ name: 'feature-index.jsonic' }, () => UpdateIndex({
+          content: ctx$.meta.content.feature_index,
+          names: features,
+        }))
       })
 
       each(target, (target) =>
-        Folder({ name: 'tm/' + target.name + '/src/feature/' + name }, () => {
+        Folder({ name: 'tm/' + target.name + '/src/feature/' + fname }, () => {
+          const from = Path.join(
+            (target.base || Path.join(BASE, '/project/.sdk')),
+            'tm',
+            target.name,
+            '/src/feature/',
+            fname
+          )
+
           Copy({
-            from: BASE + '/project/.sdk/tm/' + target.name + '/src/feature/' + name,
+            // from: BASE + '/project/.sdk/tm/' + target.name + '/src/feature/' + name,
+            from,
             exclude: true
           })
         }))
 
+      log.info({
+        point: 'feature-done', feature: fname,
+        note: fname
+      })
     })
   })
 
-  modifyModel({
-    features,
-    model: ctx$.meta.model,
-    tree: ctx$.meta.tree,
-    fs: ctx$.fs
-  })
-
 })
 
 
-async function modifyModel({ features, 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 feature file references into model
-  features.sort().map((feature: string) => {
-    const lineRE =
-      new RegExp(`@"feature/${feature}.jsonic"`)
-    if (!src.match(lineRE)) {
-      src = src.replace(/(main:\s+sdk:\s+feature:\s+\{\s*\}\n)/, '$1' +
-        `@"feature/${feature}.jsonic"\n`)
-    }
-  })
-
-  fs().writeFileSync(path, src)
-}
-
-
 export {
-  action_feature
+  feature_add,
+  action_feature,
 }

package/src/action/target.ts

@@ -1,25 +1,48 @@
 
+import Path from 'node:path'
+
 import {
-  Jostraca,
   Project,
-  File,
   Folder,
-  Content,
   Copy,
+  File,
   cmp,
   each,
 } from 'jostraca'
 
+import { showChanges } from '@voxgig/util'
+
+import { getelem } from '@voxgig/struct'
+
+import type {
+  ActionContext,
+  ActionResult,
+} from '../types'
 
 import { SdkGenError } from '../utility'
 
+import {
+  feature_add
+} from './feature'
+
+import {
+  UpdateIndex,
+  loadContent,
+} from './action'
+
 
 const CMD_MAP: any = {
   add: cmd_target_add
 }
 
-async function action_target(args: any[], ctx: any) {
 
+type Target = {
+  origin: string
+  name: string
+}
+
+
+async function action_target(args: string[], actx: ActionContext): Promise<ActionResult> {
   const cmdname = args[1]
 
   const cmd = CMD_MAP[cmdname]
@@ -28,106 +51,203 @@ async function action_target(args: any[], ctx: any) {
     throw new SdkGenError('Unknown target cmd: ' + cmdname)
   }
 
-  await cmd(args, ctx)
+  return await cmd(args, actx)
 }
 
 
-async function cmd_target_add(args: any[], ctx: any) {
+async function cmd_target_add(args: string[], actx: ActionContext): Promise<ActionResult> {
+  const targets_arg = args[2]
+  const targets: string[] =
+    'string' === typeof targets_arg ? targets_arg.split(',') : targets_arg
+
+  return target_add(targets, actx)
+}
 
-  let targets = args[2]
-  targets = 'string' === typeof targets ? targets.split(',') : targets
 
-  const jostraca = Jostraca()
+// Code API
+async function target_add(targets: string[], actx: ActionContext): Promise<ActionResult> {
+  // const jostraca = Jostraca()
+  const jostraca = actx.jostraca
 
   const opts = {
-    fs: ctx.fs,
-    folder: ctx.folder,
-    log: ctx.log.child({ cmp: 'jostraca' }),
-    meta: { model: ctx.model, tree: ctx.tree },
-    model: ctx.model
+    fs: actx.fs,
+    folder: actx.folder,
+    log: actx.log.child({ cmp: 'jostraca' }),
+    meta: {
+      // model: actx.model,
+      tree: actx.tree,
+      content: loadContent(actx, 'target')
+    },
+    model: actx.model,
   }
 
-  await jostraca.generate(opts, () => TargetRoot({ targets }))
+  opts.log.info({
+    point: 'target-start',
+    note: (actx.opts.dryrun ? '** DRY RUN **' : '')
+  })
+
+
+  const jres = await jostraca.generate(opts, () => TargetRoot({ targets, actx }))
+
+  showChanges(opts.log, 'target-result', jres)
 
+  const features = Object.keys(actx.model.main.sdk.feature)
+  await feature_add(features, actx)
+
+  opts.log.info({
+    point: 'target-end',
+    note: (actx.opts.dryrun ? '** DRY RUN **' : '')
+  })
+
+  return {
+    jres
+  }
 }
 
 
 const TargetRoot = cmp(function TargetRoot(props: any) {
   const { ctx$, targets } = props
+  const { model, log } = ctx$
 
-  // TODO: model should be a top level ctx property
-  // ctx$.model = ctx$.meta.model
-
-  // console.log('MODEL')
-  // console.dir(ctx$.model, { depth: null })
-
-  const { model } = ctx$
+  // TODO: jostraca - make from value easier to specify 
+  // const tfolder = 'node_modules/@voxgig/sdkgen/project/.sdk'
 
   Project({}, () => {
     each(targets, (n) => {
-      // TODO: validate target is a-z0-9-_. only
-      const name = n.val$
+      const tref = n.val$
+
+      log.info({
+        point: 'target-build',
+        target: tref,
+        note: tref
+      })
+
+      const { tname, tfolder, torigname, base } = resolveTarget(tref, ctx$)
+      const targetNote = tname + (tname != tref ? ' ref:' + tref : '')
+
+      log.info({
+        point: 'target-name', name: tname, folder: tfolder,
+        target: tref,
+        tname,
+        note: tname + (tname != torigname ? 'original' + torigname : '') + ' from:' + tfolder
+      })
 
       Folder({ name: 'model/target' }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/.sdk/model/target/' + name + '.jsonic',
+          from: tfolder + '/model/target/' + torigname + '.jsonic',
           // exclude: true
+          replace: {
+            "'BASE'": "'" + base + "'"
+          }
         })
+        File({ name: 'target-index.jsonic' }, () => UpdateIndex({
+          content: ctx$.meta.content.target_index,
+          // names: targets,
+          names: [tname]
+        }))
       })
 
-      Folder({ name: 'src/cmp/' + name }, () => {
+      Folder({ name: 'src/cmp/' + tname }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/.sdk/src/cmp/' + name,
+          from: tfolder + '/src/cmp/' + torigname,
           // exclude: true
         })
       })
 
-      Folder({ name: 'tm/' + name }, () => {
+      Folder({ name: 'tm/' + tname }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/.sdk/tm/' + name,
+          from: tfolder + '/tm/' + torigname,
           exclude: [/src\/feature/],
           replace: {
-            Name: model.const.Name,
+
+            // TODO: standard replacements
+            ProjectName: model.const.Name,
           }
         })
+
+        Folder({ name: 'src/feature' }, () => {
+          Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/README.md' })
+
+          Folder({ name: 'base' }, () => {
+            Copy({ from: tfolder + '/tm/' + torigname + '/src/feature/base' })
+          })
+        })
       })
 
+      log.info({
+        point: 'target-done', target: tref, note: targetNote
+      })
 
     })
   })
+})
 
-  modifyModel({
-    targets,
-    model: ctx$.meta.model,
-    tree: ctx$.meta.tree,
-    fs: ctx$.fs
-  })
 
-})
+function resolveTarget(tref: string, ctx$: any) {
+  let tname = tref
+  let torigname = tref
+  let tfolder = 'node_modules/@voxgig/sdkgen/project/.sdk'
 
+  const root = ctx$.folder
+  const 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
+  let fulltfolder = Path.normalize(Path.join(root, tfolder))
+  tname = getelem(tref.split('/'), -1)
 
-  const path = tree.url
-  let src = fs().readFileSync(path, 'utf8')
+  let aliasref = tref
+  torigname = getelem(aliasref.split('/'), -1)
+  const aliasing = tref.split('~')
+  if (1 < aliasing.length) {
+    aliasref = aliasing[0]
+    tname = aliasing.slice(1).join('~')
+    torigname = getelem(aliasref.split('/'), -1)
+  }
 
-  // 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`)
+  const search: string[] = []
+  let found = false
+  if (aliasref.includes('/')) {
+    // NOTE: the last path element of the ref is the target name, not a folder.
+    const aliasbase = Path.dirname(aliasref)
+
+    if (!aliasref.startsWith('/')) {
+      fulltfolder = Path.normalize(Path.join(root, 'node_modules', aliasbase, '.sdk'))
+      search.push(fulltfolder)
+      found = fs.existsSync(fulltfolder)
+
+      if (!found) {
+        fulltfolder = Path.normalize(Path.join(root, aliasbase, '.sdk'))
+        search.push(fulltfolder)
+        found = fs.existsSync(fulltfolder)
+      }
     }
-  })
+    else {
+      fulltfolder = Path.normalize(Path.join(aliasbase, '.sdk'))
+      search.push(fulltfolder)
+      found = fs.existsSync(fulltfolder)
+    }
+  }
+  else {
+    search.push(fulltfolder)
+    found = fs.existsSync(fulltfolder)
+  }
+
+  if (!found) {
+    throw new Error('Target folder not found in:\n' + search.join('\n  '))
+  }
+
+  const rootslash = root.endsWith('/') ? root : root + '/'
+  const out = {
+    tname,
+    tfolder: fulltfolder,
+    torigname,
+    base: fulltfolder.replace(rootslash, '')
+  }
 
-  fs().writeFileSync(path, src)
+  return out
 }
 
 
 export {
-  action_target
+  action_target,
+  target_add,
 }

package/src/cmp/Entity.ts

@@ -8,11 +8,17 @@ import { requirePath } from '../utility'
 
 const Entity = cmp(function Entity(props: any) {
   const { target, entity, ctx$ } = props
+  const { log } = ctx$
 
   const entitySDK = ctx$.model.main.sdk.entity[entity.name]
 
   const Entity_sdk = requirePath(ctx$, `./cmp/${target.name}/Entity_${target.name}`)
   Entity_sdk['Entity']({ target, entity, entitySDK })
+
+  log.info({
+    point: 'generate-entity', target, entity,
+    note: 'target:' + target.name + ', ' + 'entity: ' + entity.name
+  })
 })
 
 

package/src/cmp/Feature.ts

@@ -1,11 +1,9 @@
 
 import { cmp, Copy, Folder } from 'jostraca'
 
-import { resolvePath } from '../utility'
-
-
 const Feature = cmp(function Feature(props: any) {
   const { target, feature, ctx$ } = props
+  const { log } = ctx$
 
   Folder({ name: 'src/feature/' + feature.name }, () => {
     // TODO: Copy should just warn if from not found
@@ -18,6 +16,11 @@ const Feature = cmp(function Feature(props: any) {
     })
   })
 
+  log.info({
+    point: 'generate-feature', target, feature,
+    note: 'target:' + target.name + ', ' + 'feature: ' + feature.name
+  })
+
 })