@voxgig/sdkgen 0.35.2 → 0.36.0

package/project/.sdk/src/cmp/rb/TestEntity_rb.ts

@@ -0,0 +1,476 @@
+
+import {
+  flatten,
+  items,
+  join,
+} from '@voxgig/struct'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+import {
+  Content,
+  File,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+type OpGen = (ctx: GenCtx, step: any, index: any) => void
+
+type GenCtx = {
+  model: any
+  entity: any
+  flow: any
+  PROJUPPER: string
+}
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+
+  const target = props.target
+  const entity = props.entity
+
+  const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${entity.Name}Flow`)
+  const dobasic = basicflow && true === basicflow.active
+
+  if (!dobasic) {
+    return
+  }
+
+  const PROJUPPER = model.const.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
+
+  const ancestors = (entity.relations?.ancestors || []).flat()
+
+  // Build idmap names
+  const idnames: string[] = []
+  for (let i = 1; i <= 3; i++) idnames.push(`${entity.name}0${i}`)
+  for (const anc of ancestors) {
+    for (let i = 1; i <= 3; i++) idnames.push(`${anc}0${i}`)
+  }
+
+  const idnamesStr = idnames.map(n => `"${n}"`).join(', ')
+
+  const allSteps = Object.values(basicflow.step) as any[]
+  const updateStep = allSteps.find((s: any) => s.op === 'update')
+  const updateData = updateStep?.data
+    ? Object.entries(updateStep.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+    : []
+  const aliases = updateData.map(([k, v]: any) => [k, v])
+
+  const genCtx: GenCtx = { model, entity, flow: basicflow, PROJUPPER }
+
+  File({ name: entity.name + '_entity_test.' + target.ext }, () => {
+
+    Content(`# ${entity.Name} entity test
+
+require "minitest/autorun"
+require "json"
+require_relative "../${model.name}_sdk"
+require_relative "runner"
+
+class ${entity.Name}EntityTest < Minitest::Test
+  def test_create_instance
+    testsdk = ${model.const.Name}SDK.test(nil, nil)
+    ent = testsdk.${entity.Name}(nil)
+    assert !ent.nil?
+  end
+
+  def test_basic_flow
+    setup = ${entity.name}_basic_setup(nil)
+    client = setup[:client]
+
+`)
+
+    // Check if the flow has a create step
+    const flowHasCreate = allSteps.some((s: any) => s.op === 'create')
+    if (!flowHasCreate) {
+      Content(`    # Bootstrap entity data from existing test data.
+    ${entity.name}_ref01_data_raw = Vs.items(Helpers.to_map(
+      Vs.getprop(setup[:data], "existing.${entity.name}")))
+    ${entity.name}_ref01_data = nil
+    if ${entity.name}_ref01_data_raw.length > 0
+      ${entity.name}_ref01_data = Helpers.to_map(${entity.name}_ref01_data_raw[0][1])
+    end
+
+`)
+    }
+
+    // Model-driven step iteration
+    each(basicflow.step, (step: any, index: any) => {
+      const opgen: OpGen = GENERATE_OP[step.op]
+      if (opgen) {
+        opgen(genCtx, step, index)
+        Content('\n')
+      }
+    })
+
+    Content(`  end
+end
+
+`)
+
+    // Generate setup function
+    Content(`def ${entity.name}_basic_setup(extra)
+  Runner.load_env_local
+
+  entity_data_file = File.join(__dir__, "..", "..", ".sdk", "test", "entity", "${entity.name}", "${entity.Name}TestData.json")
+  entity_data_source = File.read(entity_data_file)
+  entity_data = JSON.parse(entity_data_source)
+
+  options = {}
+  options["entity"] = entity_data["existing"]
+
+  client = ${model.const.Name}SDK.test(options, extra)
+
+`)
+
+    // Generate idmap via Vs.transform
+    Content(`  # Generate idmap via transform.
+  idmap = Vs.transform(
+    [${idnamesStr}],
+    {
+      "\`$PACK\`" => ["", {
+        "\`$KEY\`" => "\`$COPY\`",
+        "\`$VAL\`" => ["\`$FORMAT\`", "upper", "\`$COPY\`"],
+      }],
+    }
+  )
+
+`)
+
+    Content(`  env = Runner.env_override({
+    "${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID" => idmap,
+    "${PROJUPPER}_TEST_LIVE" => "FALSE",
+    "${PROJUPPER}_TEST_EXPLAIN" => "FALSE",
+    "${PROJUPPER}_APIKEY" => "NONE",
+  })
+
+  idmap_resolved = Helpers.to_map(
+    env["${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID"])
+  if idmap_resolved.nil?
+    idmap_resolved = Helpers.to_map(idmap)
+  end
+`)
+
+    // Add aliases
+    for (const [key, val] of aliases) {
+      Content(`  if idmap_resolved["${key}"].nil?
+    idmap_resolved["${key}"] = idmap_resolved["${val}"]
+  end
+`)
+    }
+
+    Content(`
+  if env["${PROJUPPER}_TEST_LIVE"] == "TRUE"
+    merged_opts = Vs.merge([
+      {
+        "apikey" => env["${PROJUPPER}_APIKEY"],
+      },
+      extra || {},
+    ])
+    client = ${model.const.Name}SDK.new(Helpers.to_map(merged_opts))
+  end
+
+  {
+    client: client,
+    data: entity_data,
+    idmap: idmap_resolved,
+    env: env,
+    explain: env["${PROJUPPER}_TEST_EXPLAIN"] == "TRUE",
+    now: (Time.now.to_f * 1000).to_i,
+  }
+end
+`)
+  })
+})
+
+
+function getMatchEntries(step: any): [string, any][] {
+  if (!step?.match) return []
+  return Object.entries(step.match).filter(([k]: any) => !k.endsWith('$'))
+}
+
+
+const generateCreate: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  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 priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const needsEnt = !priorSteps.some((s: any) =>
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+
+  const hasDatvar = priorSteps.some((s: any) => {
+    if ('create' === s.op) {
+      const priorRef = s.input?.ref ?? entity.name + '_ref01'
+      const priorDatvar = s.input?.datavar ?? (priorRef + '_data' + (s.input?.suffix ?? ''))
+      return priorDatvar === datavar
+    }
+    return false
+  })
+
+  Content(`    # CREATE
+`)
+  if (needsEnt) {
+    Content(`    ${entvar} = client.${entity.Name}(nil)
+`)
+  }
+
+  if (hasDatvar) {
+    Content(`    ${datavar} = Helpers.to_map(Vs.getprop(
+      Vs.getpath(setup[:data], "new.${entity.name}"), "${ref}"))
+`)
+  } else {
+    Content(`    ${datavar} = Helpers.to_map(Vs.getprop(
+      Vs.getpath(setup[:data], "new.${entity.name}"), "${ref}"))
+`)
+  }
+
+  const matchEntries = getMatchEntries(step)
+  for (const [key, val] of matchEntries) {
+    Content(`    ${datavar}["${key}"] = setup[:idmap]["${val}"]
+`)
+  }
+
+  Content(`
+    ${datavar}_result, err = ${entvar}.create(${datavar}, nil)
+    assert_nil err
+    ${datavar} = Helpers.to_map(${datavar}_result)
+    assert !${datavar}.nil?
+    assert !${datavar}["id"].nil?
+`)
+}
+
+
+const generateList: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  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 ?? ''))
+
+  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const needsEnt = !priorSteps.some((s: any) =>
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+
+  Content(`    # LIST
+`)
+  if (needsEnt) {
+    Content(`    ${entvar} = client.${entity.Name}(nil)
+`)
+  }
+
+  const matchEntries = getMatchEntries(step)
+  if (matchEntries.length === 0) {
+    Content(`    ${matchvar} = {}
+`)
+  } else {
+    Content(`    ${matchvar} = {
+`)
+    for (const [key, val] of matchEntries) {
+      Content(`      "${key}" => setup[:idmap]["${val}"],
+`)
+    }
+    Content(`    }
+`)
+  }
+
+  Content(`
+    ${listvar}_result, err = ${entvar}.list(${matchvar}, nil)
+    assert_nil err
+    assert ${listvar}_result.is_a?(Array)
+`)
+
+  // Handle validators
+  const allSteps = Object.values(flow.step) as any[]
+  if (step.valid) {
+    for (const validator of step.valid) {
+      const validRef = validator.def?.ref
+      const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
+        ((s.input?.ref ?? entity.name + '_ref01') === validRef))
+
+      if ('ItemExists' === validator.apply && hasRefData) {
+        const refDataVar = validRef + '_data'
+        Content(`
+    found_item = Vs.select(
+      Runner.entity_list_to_data(${listvar}_result),
+      { "id" => ${refDataVar}["id"] })
+    assert !Vs.isempty(found_item)
+`)
+      } else if ('ItemNotExists' === validator.apply && hasRefData) {
+        const refDataVar = validRef + '_data'
+        Content(`
+    not_found_item = Vs.select(
+      Runner.entity_list_to_data(${listvar}_result),
+      { "id" => ${refDataVar}["id"] })
+    assert Vs.isempty(not_found_item)
+`)
+      }
+    }
+  }
+}
+
+
+const generateUpdate: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  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 ?? ''))
+
+  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const needsEnt = !priorSteps.some((s: any) =>
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+
+  Content(`    # UPDATE
+`)
+  if (needsEnt) {
+    Content(`    ${entvar} = client.${entity.Name}(nil)
+`)
+  }
+  Content(`    ${datavar}_up = {
+      "id" => ${srcdatavar}["id"],
+`)
+
+  if (step.data) {
+    const dataEntries = Object.entries(step.data).filter(([k]: any) => k !== 'id' && !k.endsWith('$'))
+    for (const [key] of dataEntries) {
+      Content(`      "${key}" => setup[:idmap]["${key}"],
+`)
+    }
+  }
+
+  Content(`    }
+`)
+
+  if (step.spec) {
+    for (const spec of step.spec) {
+      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+        const fieldname = step.input.textfield
+        const fieldvalue = spec.def?.mark ?? `Mark01-${ref}`
+        Content(`
+    ${markdefvar}_name = "${fieldname}"
+    ${markdefvar}_value = "${fieldvalue}_#{setup[:now]}"
+    ${datavar}_up[${markdefvar}_name] = ${markdefvar}_value
+`)
+      }
+    }
+  }
+
+  Content(`
+    ${resdatavar}_result, err = ${entvar}.update(${datavar}_up, nil)
+    assert_nil err
+    ${resdatavar} = Helpers.to_map(${resdatavar}_result)
+    assert !${resdatavar}.nil?
+    assert_equal ${resdatavar}["id"], ${datavar}_up["id"]
+`)
+
+  if (step.spec) {
+    for (const spec of step.spec) {
+      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+        Content(`    assert_equal ${resdatavar}[${markdefvar}_name], ${markdefvar}_value
+`)
+      }
+    }
+  }
+}
+
+
+const generateLoad: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  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 ?? ''))
+
+  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const hasEntVar = priorSteps.some((s: any) =>
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+
+  const flowHasCreate = Object.values(flow.step).some((s: any) => (s as any).op === 'create')
+  const preambleRef = entity.name + '_ref01'
+  const hasSrcData = (!flowHasCreate && srcdatavar === (preambleRef + '_data')) ||
+    priorSteps.some((s: any) => {
+      if ('create' === s.op) {
+        const priorRef = s.input?.ref ?? entity.name + '_ref01'
+        const priorDatvar = s.input?.datavar ?? (priorRef + '_data' + (s.input?.suffix ?? ''))
+        return priorDatvar === srcdatavar
+      }
+      return false
+    })
+
+  Content(`    # LOAD
+`)
+  if (!hasEntVar) {
+    Content(`    ${entvar} = client.${entity.Name}(nil)
+`)
+  }
+  if (!hasSrcData) {
+    Content(`    ${srcdatavar}_raw = Vs.items(Helpers.to_map(
+      Vs.getprop(setup[:data], "existing.${entity.name}")))
+    ${srcdatavar} = nil
+    if ${srcdatavar}_raw.length > 0
+      ${srcdatavar} = Helpers.to_map(${srcdatavar}_raw[0][1])
+    end
+`)
+  }
+  Content(`    ${matchvar} = {
+      "id" => ${srcdatavar}["id"],
+    }
+    ${datavar}_loaded, err = ${entvar}.load(${matchvar}, nil)
+    assert_nil err
+    ${datavar}_load_result = Helpers.to_map(${datavar}_loaded)
+    assert !${datavar}_load_result.nil?
+    assert_equal ${datavar}_load_result["id"], ${srcdatavar}["id"]
+`)
+}
+
+
+const generateRemove: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  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')
+
+  const priorSteps = Object.values(flow.step).slice(0, Number(index)) as any[]
+  const needsEnt = !priorSteps.some((s: any) =>
+    ['create', 'list', 'load', 'update', 'remove'].includes(s.op))
+
+  Content(`    # REMOVE
+`)
+  if (needsEnt) {
+    Content(`    ${entvar} = client.${entity.Name}(nil)
+`)
+  }
+  Content(`    ${matchvar} = {
+      "id" => ${srcdatavar}["id"],
+    }
+    _, err = ${entvar}.remove(${matchvar}, nil)
+    assert_nil err
+`)
+}
+
+
+const GENERATE_OP: Record<string, OpGen> = {
+  create: generateCreate,
+  list: generateList,
+  update: generateUpdate,
+  load: generateLoad,
+  remove: generateRemove,
+}
+
+
+export {
+  TestEntity
+}

package/project/.sdk/src/cmp/rb/Test_rb.ts

@@ -0,0 +1,50 @@
+
+import {
+  KIT,
+  getModelPath
+} from '@voxgig/apidef'
+
+import type {
+  ModelEntity
+} from '@voxgig/apidef'
+
+import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestEntity } from './TestEntity_rb'
+import { TestDirect } from './TestDirect_rb'
+
+
+const Test = cmp(function Test(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target } = props
+
+  Folder({ name: 'test' }, () => {
+
+    // Generate exists test
+    File({ name: 'exists_test.' + target.ext }, () => {
+      Content(`# ${model.const.Name} SDK exists test
+
+require "minitest/autorun"
+require_relative "../${model.name}_sdk"
+
+class ExistsTest < Minitest::Test
+  def test_create_test_sdk
+    testsdk = ${model.const.Name}SDK.test(nil, nil)
+    assert !testsdk.nil?
+  end
+end
+`)
+    })
+
+    each(model.main[KIT].entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity })
+      TestDirect({ target, entity })
+    })
+  })
+})
+
+
+export {
+  Test
+}

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

@@ -0,0 +1,116 @@
+# ProjectName SDK EntityName entity
+
+require_relative '../utility/struct/voxgig_struct'
+require_relative '../core/helpers'
+
+class EntityNameEntity
+  def initialize(client, entopts = nil)
+    entopts ||= {}
+    if entopts["active"].nil?
+      entopts["active"] = true
+    elsif entopts["active"] == false
+      # keep false
+    else
+      entopts["active"] = true
+    end
+
+    @_name = "entityname"
+    @_client = client
+    @_utility = client.get_utility
+    @_entopts = entopts
+    @_data = {}
+    @_match = {}
+
+    @_entctx = @_utility.make_context.call({
+      "entity" => self,
+      "entopts" => entopts,
+    }, client.get_root_ctx)
+
+    @_utility.feature_hook.call(@_entctx, "PostConstructEntity")
+  end
+
+  def get_name
+    @_name
+  end
+
+  def make
+    opts = @_entopts.dup
+    EntityNameEntity.new(@_client, opts)
+  end
+
+  def data_set(args)
+    if args
+      @_data = ProjectNameHelpers.to_map(VoxgigStruct.clone(args)) || {}
+      @_utility.feature_hook.call(@_entctx, "SetData")
+    end
+  end
+
+  def data_get
+    @_utility.feature_hook.call(@_entctx, "GetData")
+    VoxgigStruct.clone(@_data)
+  end
+
+  def match_set(args)
+    if args
+      @_match = ProjectNameHelpers.to_map(VoxgigStruct.clone(args)) || {}
+      @_utility.feature_hook.call(@_entctx, "SetMatch")
+    end
+  end
+
+  def match_get
+    @_utility.feature_hook.call(@_entctx, "GetMatch")
+    VoxgigStruct.clone(@_match)
+  end
+
+  # #LoadOp
+
+  # #ListOp
+
+  # #CreateOp
+
+  # #UpdateOp
+
+  # #RemoveOp
+
+  private
+
+  def _run_op(ctx, &post_done)
+    utility = @_utility
+
+    # #PrePoint-Hook
+
+    point, err = utility.make_point.call(ctx)
+    ctx.out["point"] = point
+    return utility.make_error.call(ctx, err) if err
+
+    # #PreSpec-Hook
+
+    spec, err = utility.make_spec.call(ctx)
+    ctx.out["spec"] = spec
+    return utility.make_error.call(ctx, err) if err
+
+    # #PreRequest-Hook
+
+    resp, err = utility.make_request.call(ctx)
+    ctx.out["request"] = resp
+    return utility.make_error.call(ctx, err) if err
+
+    # #PreResponse-Hook
+
+    resp2, err = utility.make_response.call(ctx)
+    ctx.out["response"] = resp2
+    return utility.make_error.call(ctx, err) if err
+
+    # #PreResult-Hook
+
+    result, err = utility.make_result.call(ctx)
+    ctx.out["result"] = result
+    return utility.make_error.call(ctx, err) if err
+
+    # #PreDone-Hook
+
+    post_done.call
+
+    utility.done.call(ctx)
+  end
+end

package/project/.sdk/src/cmp/rb/fragment/EntityCreateOp.fragment.rb

@@ -0,0 +1,25 @@
+require_relative '../utility/struct/voxgig_struct'
+require_relative '../core/helpers'
+
+# EJECT-START
+
+  def create(reqdata, ctrl = nil)
+    utility = @_utility
+    ctx = utility.make_context.call({
+      "opname" => "create",
+      "ctrl" => ctrl,
+      "match" => @_match,
+      "data" => @_data,
+      "reqdata" => reqdata,
+    }, @_entctx)
+
+    _run_op(ctx) do
+      if ctx.result
+        if ctx.result.resdata
+          @_data = ProjectNameHelpers.to_map(VoxgigStruct.clone(ctx.result.resdata)) || {}
+        end
+      end
+    end
+  end
+
+# EJECT-END

package/project/.sdk/src/cmp/rb/fragment/EntityListOp.fragment.rb

@@ -0,0 +1,20 @@
+# EJECT-START
+
+  def list(reqmatch, ctrl = nil)
+    utility = @_utility
+    ctx = utility.make_context.call({
+      "opname" => "list",
+      "ctrl" => ctrl,
+      "match" => @_match,
+      "data" => @_data,
+      "reqmatch" => reqmatch,
+    }, @_entctx)
+
+    _run_op(ctx) do
+      if ctx.result
+        @_match = ctx.result.resmatch if ctx.result.resmatch
+      end
+    end
+  end
+
+# EJECT-END

package/project/.sdk/src/cmp/rb/fragment/EntityLoadOp.fragment.rb

@@ -0,0 +1,26 @@
+require_relative '../utility/struct/voxgig_struct'
+require_relative '../core/helpers'
+
+# EJECT-START
+
+  def load(reqmatch, ctrl = nil)
+    utility = @_utility
+    ctx = utility.make_context.call({
+      "opname" => "load",
+      "ctrl" => ctrl,
+      "match" => @_match,
+      "data" => @_data,
+      "reqmatch" => reqmatch,
+    }, @_entctx)
+
+    _run_op(ctx) do
+      if ctx.result
+        @_match = ctx.result.resmatch if ctx.result.resmatch
+        if ctx.result.resdata
+          @_data = ProjectNameHelpers.to_map(VoxgigStruct.clone(ctx.result.resdata)) || {}
+        end
+      end
+    end
+  end
+
+# EJECT-END