@voxgig/sdkgen 0.16.0 → 0.18.0

package/project/.sdk/tm/js/test/utility/StructUtility.test.js

@@ -0,0 +1,367 @@
+
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const { test, describe } = require('node:test')
+const { equal, deepEqual, fail } = require('node:assert')
+
+
+const {
+  clone,
+  escre,
+  escurl,
+  getpath,
+  getprop,
+  inject,
+  isempty,
+  iskey,
+  islist,
+  ismap,
+  isnode,
+  items,
+  haskey,
+  keysof,
+  merge,
+  setprop,
+  stringify,
+  transform,
+  walk,
+  validate,
+  joinurl,
+} = require('../../src/utility/StructUtility')
+
+
+const { runner } = require('../runner')
+
+
+function walkpath(_key, val, _parent, path) {
+  return 'string' === typeof val ? val + '~' + path.join('.') : val
+}
+
+
+function nullModifier(
+  key,
+  val,
+  parent
+) {
+  if ("__NULL__" === val) {
+    setprop(parent, key, null)
+  }
+  else if ('string' === typeof val) {
+    setprop(parent, key, val.replaceAll('__NULL__', 'null'))
+  }
+}
+
+
+describe('struct', async () => {
+
+  const { spec, runset, subject } = await runner('struct')
+
+  
+  // minor tests
+  // ===========
+
+  test('minor-exists', () => {
+    equal('function', typeof clone)
+    equal('function', typeof escre)
+    equal('function', typeof escurl)
+    equal('function', typeof getprop)
+    equal('function', typeof isempty)
+    equal('function', typeof iskey)
+    equal('function', typeof islist)
+    equal('function', typeof ismap)
+    equal('function', typeof isnode)
+    equal('function', typeof items)
+    equal('function', typeof setprop)
+    equal('function', typeof stringify)
+    equal('function', typeof haskey)
+    equal('function', typeof keysof)
+    equal('function', typeof joinurl)
+  })
+
+  test('minor-clone', async () => {
+    await runset(spec.minor.clone, clone)
+  })
+
+  test('minor-isnode', async () => {
+    await runset(spec.minor.isnode, isnode)
+  })
+
+  test('minor-ismap', async () => {
+    await runset(spec.minor.ismap, ismap)
+  })
+
+  test('minor-islist', async () => {
+    await runset(spec.minor.islist, islist)
+  })
+
+  test('minor-iskey', async () => {
+    await runset(spec.minor.iskey, iskey)
+  })
+
+  test('minor-isempty', async () => {
+    await runset(spec.minor.isempty, isempty)
+  })
+
+  test('minor-escre', async () => {
+    await runset(spec.minor.escre, escre)
+  })
+
+  test('minor-escurl', async () => {
+    await runset(spec.minor.escurl, escurl)
+  })
+
+  test('minor-stringify', async () => {
+    await runset(spec.minor.stringify, (vin) =>
+      null == vin.max ? stringify(vin.val) : stringify(vin.val, vin.max))
+  })
+
+  test('minor-items', async () => {
+    await runset(spec.minor.items, items)
+  })
+
+  test('minor-getprop', async () => {
+    await runset(spec.minor.getprop, (vin) =>
+      null == vin.alt ? getprop(vin.val, vin.key) : getprop(vin.val, vin.key, vin.alt))
+  })
+
+  test('minor-setprop', async () => {
+    await runset(spec.minor.setprop, (vin) =>
+      setprop(vin.parent, vin.key, vin.val))
+  })
+
+  test('minor-haskey', async () => {
+    await runset(spec.minor.haskey, haskey)
+  })
+
+  test('minor-keysof', async () => {
+    await runset(spec.minor.keysof, keysof)
+  })
+
+  test('minor-joinurl', async () => {
+    await runset(spec.minor.joinurl, joinurl)
+  })
+
+
+  // walk tests
+  // ==========
+
+  test('walk-exists', async () => {
+    equal('function', typeof merge)
+  })
+
+  test('walk-basic', async () => {
+    await runset(spec.walk.basic, (vin) => walk(vin, walkpath))
+  })
+
+
+  // merge tests
+  // ===========
+
+  test('merge-exists', async () => {
+    equal('function', typeof merge)
+  })
+
+  test('merge-basic', async () => {
+    const test = clone(spec.merge.basic)
+    deepEqual(merge(test.in), test.out)
+  })
+
+  test('merge-cases', async () => {
+    await runset(spec.merge.cases, merge)
+  })
+
+  test('merge-array', async () => {
+    await runset(spec.merge.array, merge)
+  })
+
+  test('merge-special', async () => {
+    const f0 = ()=>null
+    deepEqual(merge([f0]), f0)
+    deepEqual(merge([null,f0]), f0)
+    deepEqual(merge([{a:f0}]), {a:f0})
+    deepEqual(merge([{a:{b:f0}}]), {a:{b:f0}})
+
+    deepEqual(merge([{a:global.fetch}]), {a:global.fetch})
+    deepEqual(merge([{a:{b:global.fetch}}]), {a:{b:global.fetch}})
+  })
+  
+
+  // getpath tests
+  // =============
+
+  test('getpath-exists', async () => {
+    equal('function', typeof getpath)
+  })
+
+  test('getpath-basic', async () => {
+    await runset(spec.getpath.basic, (vin) => getpath(vin.path, vin.store))
+  })
+
+  test('getpath-current', async () => {
+    await runset(spec.getpath.current, (vin) =>
+      getpath(vin.path, vin.store, vin.current))
+  })
+
+  test('getpath-state', async () => {
+    const state = {
+      handler: (state, val, _current, _store) => {
+        let out = state.step + ':' + val
+        state.step++
+        return out
+      },
+      step: 0,
+      mode: 'val',
+      full: false,
+      keyI: 0,
+      keys: ['$TOP'],
+      key: '$TOP',
+      val: '',
+      parent: {},
+      path: ['$TOP'],
+      nodes: [{}],
+      base: '$TOP'
+    }
+    await runset(spec.getpath.state, (vin) =>
+      getpath(vin.path, vin.store, vin.current, state))
+  })
+
+
+  // inject tests
+  // ============
+
+  test('inject-exists', async () => {
+    equal('function', typeof inject)
+  })
+
+  test('inject-basic', async () => {
+    const test = clone(spec.inject.basic)
+    deepEqual(inject(test.in.val, test.in.store), test.out)
+  })
+
+  test('inject-string', async () => {
+    await runset(spec.inject.string, (vin) =>
+      inject(vin.val, vin.store, nullModifier, vin.current))
+  })
+
+  test('inject-deep', async () => {
+    await runset(spec.inject.deep, (vin) => inject(vin.val, vin.store))
+  })
+
+
+  // transform tests
+  // ===============
+
+  test('transform-exists', async () => {
+    equal('function', typeof transform)
+  })
+
+  test('transform-basic', async () => {
+    const test = clone(spec.transform.basic)
+    deepEqual(transform(test.in.data, test.in.spec, test.in.store), test.out)
+  })
+
+  test('transform-paths', async () => {
+    await runset(spec.transform.paths, (vin) =>
+      transform(vin.data, vin.spec, vin.store))
+  })
+
+  test('transform-cmds', async () => {
+    await runset(spec.transform.cmds, (vin) =>
+      transform(vin.data, vin.spec, vin.store))
+  })
+
+  test('transform-each', async () => {
+    await runset(spec.transform.each, (vin) =>
+      transform(vin.data, vin.spec, vin.store))
+  })
+
+  test('transform-pack', async () => {
+    await runset(spec.transform.pack, (vin) =>
+      transform(vin.data, vin.spec, vin.store))
+  })
+
+
+  test('transform-modify', async () => {
+    await runset(spec.transform.modify, (vin) =>
+      transform(vin.data, vin.spec, vin.store,
+        (key, val, parent) => {
+          if (null != key && null != parent && 'string' === typeof val) {
+            val = parent[key] = '@' + val
+          }
+        }
+      ))
+  })
+
+  test('transform-extra', async () => {
+    deepEqual(transform(
+      { a: 1 },
+      { x: '`a`', b: '`$COPY`', c: '`$UPPER`' },
+      {
+        b: 2, $UPPER: (state) => {
+          const { path } = state
+          return ('' + getprop(path, path.length - 1)).toUpperCase()
+        }
+      }
+    ), {
+      x: 1,
+      b: 2,
+      c: 'C'
+    })
+  })
+
+
+  test('transform-funcval', async () => {
+    const f0 = ()=>99
+    deepEqual(transform({},{x:1}), {x:1})
+    deepEqual(transform({},{x:f0}), {x:f0})
+    deepEqual(transform({a:1},{x:'`a`'}), {x:1})
+    deepEqual(transform({f0},{x:'`f0`'}), {x:f0})
+  })
+
+  
+  // validate tests
+  // ===============
+
+  test('validate-exists', async () => {
+    equal('function', typeof validate)
+  })
+
+  
+  test('validate-basic', async () => {
+    await runset(spec.validate.basic, (vin)=>validate(vin.data,vin.spec))
+  })
+
+
+  test('validate-node', async () => {
+    await runset(spec.validate.node, (vin)=>validate(vin.data,vin.spec))
+  })
+
+
+  test('validate-custom', async () => {
+    const errs = []
+    const extra = {
+      $INTEGER: (state, val, current)=>{
+        const { mode, key, parent } = state
+        let out = getprop(current, key)
+
+        let t = typeof out
+        if('number' !== t && !Number.isInteger(out)) {
+          state.errs.push('Not an integer at '+state.path.slice(1).join('.')+': '+out)
+          return
+        }
+
+        return out
+      },
+    }
+
+    validate({a:1},{a:'`$INTEGER`'},extra,errs)
+    equal(errs.length, 0)
+
+    validate({a:'A'},{a:'`$INTEGER`'},extra,errs)
+    deepEqual(errs, [ 'Not an integer at a: A' ])
+  })
+
+
+})
+
+

package/project/.sdk/tm/py/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ $$const.Name$$
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/ts/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) $$const.year$$ $$const.Name$$
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/project/.sdk/tm/ts/src/README.md

@@ -0,0 +1 @@
+# src

package/project/.sdk/tm/ts/src/feature/README.md

@@ -0,0 +1 @@
+# Feature

package/project/.sdk/tm/ts/src/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2021",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}

package/project/.sdk/tm/ts/src/utility/README.md

@@ -0,0 +1,3 @@
+# Utility
+
+

package/project/.sdk/tm/ts/test/README.md

@@ -0,0 +1,2 @@
+# test
+

package/project/.sdk/tm/ts/test/README.md~

@@ -0,0 +1,2 @@
+# Test
+

package/project/.sdk/tm/ts/test/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist-test",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "ES2021"
+  }
+}

package/src/action/feature.ts

@@ -20,6 +20,7 @@ const CMD_MAP: any = {
 
 const BASE = 'node_modules/@voxgig/sdkgen'
 
+
 async function action_feature(args: any[], ctx: any) {
 
   const cmdname = args[1]
@@ -49,7 +50,6 @@ async function cmd_feature_add(args: any[], ctx: any) {
   }
 
   await jostraca.generate(opts, () => FeatureRoot({ features }))
-
 }
 
 
@@ -67,7 +67,8 @@ const FeatureRoot = cmp(function FeatureRoot(props: any) {
 
       Folder({ name: 'model/feature' }, () => {
         Copy({
-          from: BASE + '/project/generate/model/feature/' + name + '.jsonic',
+          // TODO: these paths needs to be parameterised
+          from: BASE + '/project/.sdk/model/feature/' + name + '.jsonic',
           exclude: true
         })
       })
@@ -75,7 +76,7 @@ const FeatureRoot = cmp(function FeatureRoot(props: any) {
       each(target, (target) =>
         Folder({ name: 'tm/' + target.name + '/src/feature/' + name }, () => {
           Copy({
-            from: BASE + '/project/generate/tm/' + target.name + '/src/feature/' + name,
+            from: BASE + '/project/.sdk/tm/' + target.name + '/src/feature/' + name,
             exclude: true
           })
         }))

package/src/action/target.ts

@@ -43,7 +43,8 @@ async function cmd_target_add(args: any[], ctx: any) {
     fs: ctx.fs,
     folder: ctx.folder,
     log: ctx.log.child({ cmp: 'jostraca' }),
-    meta: { model: ctx.model, tree: ctx.tree }
+    meta: { model: ctx.model, tree: ctx.tree },
+    model: ctx.model
   }
 
   await jostraca.generate(opts, () => TargetRoot({ targets }))
@@ -55,11 +56,13 @@ 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
+  // ctx$.model = ctx$.meta.model
 
   // console.log('MODEL')
   // console.dir(ctx$.model, { depth: null })
 
+  const { model } = ctx$
+
   Project({}, () => {
     each(targets, (n) => {
       // TODO: validate target is a-z0-9-_. only
@@ -67,22 +70,25 @@ const TargetRoot = cmp(function TargetRoot(props: any) {
 
       Folder({ name: 'model/target' }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/generate/model/target/' + name + '.jsonic',
+          from: 'node_modules/@voxgig/sdkgen/project/.sdk/model/target/' + name + '.jsonic',
           // exclude: true
         })
       })
 
       Folder({ name: 'src/cmp/' + name }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/generate/src/cmp/' + name,
+          from: 'node_modules/@voxgig/sdkgen/project/.sdk/src/cmp/' + name,
           // exclude: true
         })
       })
 
       Folder({ name: 'tm/' + name }, () => {
         Copy({
-          from: 'node_modules/@voxgig/sdkgen/project/generate/tm/' + name,
-          exclude: [/src\/feature/]
+          from: 'node_modules/@voxgig/sdkgen/project/.sdk/tm/' + name,
+          exclude: [/src\/feature/],
+          replace: {
+            Name: model.const.Name,
+          }
         })
       })
 

package/src/cmp/Entity.ts

@@ -9,8 +9,10 @@ import { requirePath } from '../utility'
 const Entity = cmp(function Entity(props: any) {
   const { target, entity, ctx$ } = props
 
+  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 })
+  Entity_sdk['Entity']({ target, entity, entitySDK })
 })
 
 

package/src/cmp/Main.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Copy, Folder } from 'jostraca'
+import { cmp, names, Copy, Folder } from 'jostraca'
 
 import { resolvePath } from '../utility'
 
@@ -8,20 +8,40 @@ const Main = cmp(function Main(props: any) {
   const { target, ctx$ } = props
   const { model } = ctx$
 
+  names(model, model.name)
+  console.log('MODEL name', model.name, model.Name)
+
+  Copy({
+    from: 'tm/' + target.name,
+    replace: {
+
+      Name: model.Name,
+
+      // '/"`([^"]+)`"/': '$1'
+    }
+  })
+
   const Main_sdk = require(resolvePath(ctx$, `cmp/${target.name}/Main_${target.name}`))
 
   Main_sdk['Main']({ model, target })
 
-  // TODO: make optional via target model
-  Copy({ from: 'tm/' + target.name + '/LICENSE', to: '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'
+  //   })
+  // })
+
+  // Folder({ name: 'test' }, () => {
+  //   Copy({
+  //     from: 'tm/' + target.name + '/test',
+  //   })
+  // })
 
-  Folder({ name: 'src/utility' }, () => {
-    Copy({
-      from: 'tm/' + target.name + '/src/utility',
-      // TODO: make this work for folders
-      // to: target + '/src'
-    })
-  })
 })
 
 

package/src/sdkgen.ts

@@ -8,7 +8,7 @@ import { Jsonic } from 'jsonic'
 import * as JostracaModule from 'jostraca'
 import { Aontu, Context } from 'aontu'
 
-import { SdkGenError } from './utility'
+import { SdkGenError, requirePath } from './utility'
 
 import { Main } from './cmp/Main'
 import { Entity } from './cmp/Entity'
@@ -23,7 +23,7 @@ import { action_target } from './action/target'
 import { action_feature } from './action/feature'
 
 
-
+// TODO: use shape
 type SdkGenOptions = {
   folder: string
   fs: any
@@ -38,6 +38,13 @@ type SdkGenOptions = {
   }
   debug?: boolean | string
   pino?: ReturnType<typeof Pino>
+  now?: () => number
+
+  // TODO: match Jostraca
+  existing?: {
+    txt?: any
+    bin?: any
+  }
 }
 
 
@@ -53,7 +60,9 @@ const ACTION_MAP: any = {
 function SdkGen(opts: SdkGenOptions) {
   const fs = opts.fs || Fs
   const folder = opts.folder || '../'
-  const jostraca = Jostraca()
+  const now = opts.now || (() => Date.now())
+
+  const jostraca = Jostraca({ now })
 
   const pino = prettyPino('sdkgen', opts)
   const log = pino.child({ cmp: 'sdkgen' })
@@ -80,6 +89,7 @@ function SdkGen(opts: SdkGenOptions) {
       log: log.child({ cmp: 'jostraca' }),
       meta: { spec },
       debug: opts.debug,
+      existing: opts.existing
     }
 
     await jostraca.generate(jopts, () => Root({ model }))
@@ -100,10 +110,8 @@ function SdkGen(opts: SdkGenOptions) {
       throw new SdkGenError('Unknown action: ' + actname)
     }
 
-
     const { model, tree } = resolveModel()
 
-
     const ctx = {
       fs: () => fs,
       log,
@@ -294,4 +302,6 @@ export {
 
   Jostraca,
   SdkGen,
+
+  requirePath,
 }