@voxgig/sdkgen 0.24.0 → 0.26.1

package/project/.sdk/src/cmp/ts/TestEntity_ts.ts

@@ -1,13 +1,352 @@
 
-import { cmp, camelify, Content } from '@voxgig/sdkgen'
+import * as Path from 'node:path'
+
+
+import {
+  flatten,
+  items,
+  join,
+  jsonify,
+  slice,
+} from '@voxgig/struct'
+
+import {
+  KIT,
+  Model,
+  ModelEntity,
+  ModelEntityFlow,
+  ModelEntityFlowStep,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+import {
+  Content,
+  File,
+  Folder,
+  Fragment,
+  Slot,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+import {
+  projectPath
+} from './utility_ts'
+
+
+type OpGen = (model: any, entity: any, flow: any, step: any, index: any) => void
 
 
 const TestEntity = cmp(function TestEntity(props: any) {
-  const { entity } = props
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+  const stdrep = ctx$.stdrep
+
+  const target = props.target
+  const entity = props.entity
+
+  // TODO: should be a utility function
+  const ff = projectPath('src/cmp/ts/fragment/')
+
+  Folder({ name: entity.name }, () => {
+
+    File({ name: nom(entity, 'Name') + 'Entity.test.' + target.name }, () => {
+
+      Fragment({
+        from: ff + 'Entity.test.fragment.ts',
+        replace: {
+          SdkName: nom(model.const, 'Name'),
+          EntityName: nom(entity, 'Name'),
+          ...stdrep,
+        }
+      }, () => {
+
+        const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${entity.Name}Flow`)
+
+        const dobasic = basicflow && true === basicflow.active
+
+        if (!dobasic) {
+          return;
+        }
+
+        const indent = 2
+
+        const idlist = flatten([
+          '${entity.name}01',
+          '${entity.name}02',
+          '${entity.name}03',
+          flatten(items(entity.relations.ancestors, (ap: any) =>
+            items(ap[1], (a: any) =>
+              items(['01', '02', '03'], (n: any) =>
+                a[1] + n[1]))), 2)
+        ])
+
+        Slot({ name: 'basicSetup' }, () => {
+          Content(`
+function basicSetup(extra?: any) {
+  // TODO: fix test def options
+  const options: any = {} // ${jsonify(basicflow.test, { offset: indent - 2 })}
+
+  // TODO: needs test utility to resolve path
+  const entityDataFile =
+    Path.resolve(__dirname, 
+      '../../../../.sdk/test/entity/${entity.name}/${nom(entity, 'Name')}TestData.json')
+
+  // TODO: file ready util needed?
+  const entityDataSource = Fs.readFileSync(entityDataFile).toString('utf8')
+
+  // TODO: need a xlang JSON parse utility in voxgig/struct with better error msgs
+  const entityData = JSON.parse(entityDataSource)
+
+  options.entity = entityData.existing
+
+  let client = ${model.Name}SDK.test(options, extra)
+  const struct = client.utility().struct
+  const merge = struct.merge
+  const transform = struct.transform
+
+  let idmap = transform(
+    ['${join(idlist, '\',\'')}'],
+    {
+      '\`$PACK\`': ['', {
+        '\`$KEY\`': '\`$COPY\`',
+        '\`$VAL\`': ['\`$FORMAT\`', 'upper', '\`$COPY\`']
+      }]
+    })
+
+  const env = envOverride({
+    '${nom(model.const, 'NAME')}_TEST_${nom(entity, 'NAME')}_ENTID': idmap,
+    '${nom(model.const, 'NAME')}_TEST_LIVE': 'FALSE',
+    '${nom(model.const, 'NAME')}_TEST_EXPLAIN': 'FALSE',
+    '${nom(model.const, 'NAME')}_APIKEY': 'NONE',
+  })
+
+  idmap = env['${nom(model.const, 'NAME')}_TEST_${nom(entity, 'NAME')}_ENTID']
+
+  if ('TRUE' === env.${model.NAME}_TEST_LIVE) {
+    client = new ${model.Name}SDK(merge([
+      {
+        apikey: env.${nom(model.const, 'NAME')}_APIKEY,
+      },
+      extra
+    ]))
+  }
+
+  const setup = {
+    idmap,
+    env,
+    options,
+    client,
+    struct,
+    data: entityData,
+    explain: 'TRUE' === env.${nom(model.const, 'NAME')}_TEST_EXPLAIN,
+    now: Date.now(),
+  }
+
+  return setup
+}
+  `)
+        })
+
+
+        Slot({ name: 'basic' }, () => {
+          Content(`
+    const setup = basicSetup()
+    const client = setup.client
+    const struct = setup.struct
 
+    const isempty = struct.isempty
+    const select = struct.select
+
+`)
+
+          each(basicflow.step, (step: any, index: any) => {
+            const opgen: OpGen = GENERATE_OP[step.op]
+            opgen(model, entity, basicflow, step, index)
+            Content('\n')
+          })
+        })
+      })
+    })
+  })
 })
 
 
+const generateCreate: OpGen = (
+  model: Model,
+  entity: ModelEntity,
+  flow: ModelEntityFlow,
+  step: ModelEntityFlowStep,
+  index: number
+) => {
+  const ref = step.input.ref ?? entity.name + '_ref01'
+  const entvar = step.input.entvar ?? ref + '_ent'
+  const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
+
+  Content(`
+    // CREATE
+    const ${entvar} = client.${nom(entity, 'Name')}()
+    const ${datavar} =
+      await ${entvar}.create(setup.data.new.${entity.name}['${ref}'])
+    assert(null != ${datavar}.id)
+  `)
+}
+
+
+const generateList: OpGen = (
+  model: Model,
+  entity: ModelEntity,
+  flow: ModelEntityFlow,
+  step: ModelEntityFlowStep,
+  index: number
+) => {
+  const ref = step.input.ref ?? entity.name + '_ref01'
+  const entvar = step.input.entvar ?? ref + '_ent'
+  const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
+  const listvar = step.input.listvar ?? (ref + '_list' + (step.input.suffix ?? ''))
+
+  Content(`
+    // LIST
+    const ${matchvar}: any = {}
+  `)
+
+  each(step.match, (mi: any) => {
+    Content(`    ${matchvar}['${mi.key$}'] = setup.idmap['${mi.key$}']
+  `)
+  })
+
+  Content(`
+    const ${listvar} = await ${entvar}.list(${matchvar})
+`)
+  for (let vI = 0; vI < step.valid.length; vI++) {
+    const validator = step.valid[vI]
+    if ('ItemExists' === validator.apply) {
+      Content(`
+    assert(!isempty(select(${listvar}, { id: ${validator.def.ref}_data.id })))
+`)
+    }
+    else if ('ItemNotExists' === validator.apply) {
+      Content(`
+    assert(isempty(select(${listvar}, { id: ${validator.def.ref}_data.id })))
+`)
+    }
+  }
+}
+
+
+const generateUpdate: OpGen = (
+  model: Model,
+  entity: ModelEntity,
+  flow: ModelEntityFlow,
+  step: ModelEntityFlowStep,
+  index: number
+) => {
+  const ref = step.input.ref ?? entity.name + '_ref01'
+  const entvar = step.input.entvar ?? ref + '_ent'
+  const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
+  const resdatavar = step.input.resdatavar ?? (ref + '_resdata' + (step.input.suffix ?? ''))
+  const markdefvar = step.input.markdefvar ?? (ref + '_markdef' + (step.input.suffix ?? ''))
+  const srcdatavar = step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? ''))
+
+  Content(`
+    // UPDATE
+    const ${datavar}: any = {}
+    ${datavar}.id = ${srcdatavar}.id
+`)
+
+  each(step.data, (mi: any) => {
+    if ('id' !== mi.key$) {
+      Content(`    ${datavar} ['${mi.key$}'] = setup.idmap['${mi.key$}']
+`)
+    }
+  })
+
+
+  for (let sI = 0; sI < step.spec.length; sI++) {
+    const spec = step.spec[sI]
+    if ('TextFieldMark' === spec.apply && null != step.input.textfield) {
+      const fieldname = step.input.textfield
+      const fieldvalue = spec.def.mark
+      Content(`
+    const ${markdefvar} = { name: '${fieldname}', value: '${fieldvalue}_' + setup.now }
+    ${datavar} [${markdefvar}.name] = ${markdefvar}.value
+`)
+    }
+  }
+
+  Content(`
+    const ${resdatavar} = await ${entvar}.update(${datavar})
+    assert(${resdatavar}.id === ${datavar}.id)
+`)
+
+  for (let sI = 0; sI < step.spec.length; sI++) {
+    const spec = step.spec[sI]
+    if ('TextFieldMark' === spec.apply) {
+      Content(`
+    assert(${resdatavar}[${markdefvar}.name] === ${markdefvar}.value)
+`)
+    }
+  }
+
+}
+
+
+const generateLoad: OpGen = (
+  model: Model,
+  entity: ModelEntity,
+  flow: ModelEntityFlow,
+  step: ModelEntityFlowStep,
+  index: number
+) => {
+  const ref = step.input.ref ?? entity.name + '_ref01'
+  const entvar = step.input.entvar ?? ref + '_ent'
+  const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
+  const datavar = step.input.datavar ?? (ref + '_data' + (step.input.suffix ?? ''))
+  const srcdatavar = step.input.srcdatavar ?? (ref + '_data' + (step.input.suffix ?? ''))
+
+  Content(`
+    // LOAD
+    const ${matchvar}: any = {}
+    ${matchvar}.id = ${srcdatavar}.id
+    const ${datavar} = await ${entvar}.load(${matchvar})
+    assert(${datavar}.id === ${srcdatavar}.id)
+`)
+}
+
+
+const generateRemove: OpGen = (
+  model: Model,
+  entity: ModelEntity,
+  flow: ModelEntityFlow,
+  step: ModelEntityFlowStep,
+  index: number
+) => {
+  const ref = step.input.ref ?? entity.name + '_ref01'
+  const entvar = step.input.entvar ?? ref + '_ent'
+  const matchvar = step.input.matchvar ?? (ref + '_match' + (step.input.suffix ?? ''))
+  const srcdatavar = step.input.srcdatavar ?? (ref + '_data')
+
+  Content(`
+    // REMOVE
+    const ${matchvar}: any = {}
+    ${matchvar}.id = ${srcdatavar}.id
+    await ${entvar}.remove(${matchvar})
+  `)
+}
+
+
+const GENERATE_OP: Record<string, OpGen> = {
+  create: generateCreate,
+  list: generateList,
+  update: generateUpdate,
+  load: generateLoad,
+  remove: generateRemove,
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/ts/TestMain_ts.ts

@@ -2,9 +2,6 @@
 import { cmp, each, File, Content } from '@voxgig/sdkgen'
 
 
-import { TestEntity } from './TestEntity_ts'
-
-
 const TestMain = cmp(function TestMain(props: any) {
   const { target } = props
   const { model } = props.ctx$

package/project/.sdk/src/cmp/ts/Test_ts.ts

@@ -1,16 +1,34 @@
 
-import { cmp, Folder } from '@voxgig/sdkgen'
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, Folder } from '@voxgig/sdkgen'
+
 
 // import { Quick } from './Quick_ts'
-import { TestMain } from './TestMain_ts'
+// import { TestMain } from './TestMain_ts'
+import { TestEntity } from './TestEntity_ts'
 
 
 const Test = cmp(function Test(props: any) {
+  const { model, stdrep } = props.ctx$
   const { target } = props
 
   Folder({ name: 'test' }, () => {
     // Quick({ target })
-    TestMain({ target })
+    // TestMain({ target })
+
+    Folder({ name: 'entity' }, () => {
+      each(model.main[KIT].entity, (entity: ModelEntity) => {
+        TestEntity({ target, entity })
+      })
+    })
   })
 })
 

package/project/.sdk/src/cmp/ts/fragment/Config.fragment.ts

@@ -1,11 +1,38 @@
 
-const Config = {
+import { BaseFeature } from './feature/base/BaseFeature'
+// #ImportFeatures
 
-  options: {
-    base: '$$main.def.servers.0.url$$',
+
+const FEATURE_CLASS: Record<string, typeof BaseFeature> = {
+  // #FeatureClasses
+}
+
+
+class Config {
+
+  makeFeature(this: any, fn: string) {
+    const fc = FEATURE_CLASS[fn]
+    const fi = new fc()
+    // TODO: errors etc
+    return fi
+  }
+
+
+  main = {
+    name: 'ProjectName',
+  }
+
+
+  feature = {
+    // #FeatureConfigs
+  }
+
+
+  options = {
+    base: '$$main.kit.info.servers.0.url$$',
 
     auth: {
-      prefix: '$$main.sdk.config.auth.prefix$$',
+      prefix: '$$main.kit.config.auth.prefix$$',
     },
 
     headers: 'HEADERS',
@@ -14,9 +41,15 @@ const Config = {
       // #EntityConfigs
     }
   }
+
+
+  entity = 'ENTITYMAP'
 }
 
 
+const config = new Config()
+
 export {
-  Config
+  config
 }
+

package/project/.sdk/src/cmp/ts/fragment/Entity.fragment.ts

@@ -6,6 +6,9 @@ import {
   SdkNameEntity,
 } from '../SdkNameSDK'
 
+import {
+  Utility
+} from '../utility/Utility'
 
 import type {
   Operation,
@@ -14,14 +17,17 @@ import type {
 } from '../types'
 
 
+// TODO: needs Entity superclass
 class EntityNameEntity {
+  name = 'entityname'
+
   #client: SdkNameSDK
+  #utility: Utility
   #entopts: any
-  #utility: any
   #data: any
   #match: any
 
-  #_basectx: any
+  _entctx: Context
 
   constructor(client: SdkNameSDK, entopts: any) {
     // super()
@@ -34,17 +40,15 @@ class EntityNameEntity {
     this.#data = {}
     this.#match = {}
 
-    const contextify = this.#utility.contextify
-    this.#_basectx = contextify({
+    const makeContext = this.#utility.makeContext
+
+    this._entctx = makeContext({
       entity: this,
-      client,
-      utility: this.#utility,
       entopts,
-      options: client.options()
-    })
+    }, client._rootctx)
 
-    const featurehook = this.#utility.featurehook
-    featurehook(this.#_basectx, 'PostConstructEntity')
+    const featureHook = this.#utility.featureHook
+    featureHook(this._entctx, 'PostConstructEntity')
   }
 
   entopts() {
@@ -61,37 +65,42 @@ class EntityNameEntity {
 
 
   data(this: any, data?: any) {
-    const featurehook = this.#utility.featurehook
-    const ctx = this.#_basectx
+    const struct = this.#utility.struct
+    const featureHook = this.#utility.featureHook
 
     if (null != data) {
-      featurehook(ctx, 'SetData')
-      this.#data = { ...data }
+      this.#data = struct.clone(data)
+      featureHook(this._entctx, 'SetData')
     }
 
-    let out = { ...this.#data }
+    featureHook(this._entctx, 'GetData')
+    let out = struct.clone(this.#data)
 
-    featurehook(ctx, 'GetData')
     return out
   }
 
 
   match(match?: any) {
-    const featurehook = this.#utility.featurehook
-    const ctx = this.#_basectx
+    const struct = this.#utility.struct
+    const featureHook = this.#utility.featureHook
 
     if (null != match) {
-      featurehook(ctx, 'SetMatch')
-      this.#match = { ...match }
+      this.#match = struct.clone(match)
+      featureHook(this._entctx, 'SetMatch')
     }
 
-    let out = { ...this.#match }
+    featureHook(this._entctx, 'GetMatch')
+    let out = struct.clone(this.#match)
 
-    featurehook(ctx, 'GetMatch')
     return out
   }
 
 
+  toJSON() {
+    const struct = this.#utility.struct
+    return struct.merge([{}, struct.getdef(this.#data, {}), { $entity: 'EntityName' }])
+  }
+
   toString() {
     return 'EntityName ' + this.#utility.struct.jsonify(this.#data)
   }
@@ -112,32 +121,37 @@ class EntityNameEntity {
   // #RemoveOp
 
 
-
   #unexpected(this: any, ctx: Context, err: any) {
+    const clean = this.#utility.clean
+    const struct = this.#utility.struct
+
+    const delprop = struct.delprop
+    const clone = struct.clone
+    const merge = struct.merge
+
     const ctrl = ctx.ctrl
 
     ctrl.err = err
 
     if (ctrl.explain) {
-      const { clean, struct } = this.#utility
-      const { delprop, clone } = struct
-
       ctx.ctrl.explain = clean(ctx, ctx.ctrl.explain)
       delprop(ctx.ctrl.explain.result, 'err')
 
       if (null != ctx.result && null != ctx.result.err) {
-        ctrl.explain.err = clean(ctx, {
-          ...clone({ err: ctx.result.err }).err,
-          message: ctx.result.err.message,
-          stack: ctx.result.err.stack,
-        })
+        ctrl.explain.err = clean(ctx, merge([
+          clone({ err: ctx.result.err }).err,
+          {
+            message: ctx.result.err.message,
+            stack: ctx.result.err.stack,
+          }]))
       }
 
-      const cleanerr = clean(ctx, {
-        ...clone({ err }).err,
-        message: err.message,
-        stack: err.stack,
-      })
+      const cleanerr = clean(ctx, merge([
+        clone({ err }).err,
+        {
+          message: err.message,
+          stack: err.stack,
+        }]))
 
       if (null == ctrl.explain.err) {
         ctrl.explain.err = cleanerr
@@ -157,8 +171,6 @@ class EntityNameEntity {
 }
 
 
-
-
 export {
   EntityNameEntity
 }

package/project/.sdk/src/cmp/ts/fragment/Entity.test.fragment.ts

@@ -2,21 +2,23 @@
 const envlocal = __dirname + '/../../../.env.local'
 require('dotenv').config({ quiet: true, path: [envlocal] })
 
+import Path from 'node:path'
+import * as Fs from 'node:fs'
 
 import { test, describe } from 'node:test'
-import { equal } from 'node:assert'
+import assert from 'node:assert'
 
 
-import { ProjectNameSDK, BaseFeature, utility } from '../..'
+import { ProjectNameSDK, BaseFeature, stdutil } from '../../..'
 
 import {
-  makeStepData,
+  envOverride,
+  makeCtrl,
   makeMatch,
   makeReqdata,
+  makeStepData,
   makeValid,
-  makeCtrl,
-  envOverride,
-} from '../utility'
+} from '../../utility'
 
 
 describe('EntityNameEntity', async () => {
@@ -24,7 +26,7 @@ describe('EntityNameEntity', async () => {
   test('instance', async () => {
     const testsdk = ProjectNameSDK.test()
     const ent = testsdk.EntityName()
-    equal(null !== ent, true)
+    assert(null != ent)
   })