@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/src/cmp/lua/TestEntity_lua.ts

@@ -0,0 +1,485 @@
+
+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
+
+local json = require("dkjson")
+local vs = require("utility.struct.struct")
+local sdk = require("${model.name}_sdk")
+local helpers = require("core.helpers")
+local runner = require("test.runner")
+
+local _test_dir = debug.getinfo(1, "S").source:match("^@(.+/)")  or "./"
+
+describe("${entity.Name}Entity", function()
+  it("should create instance", function()
+    local testsdk = sdk.test(nil, nil)
+    local ent = testsdk:${entity.Name}(nil)
+    assert.is_not_nil(ent)
+  end)
+
+  it("should run basic flow", function()
+    local setup = ${entity.name}_basic_setup(nil)
+    local 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.
+    local ${entity.name}_ref01_data_raw = vs.items(helpers.to_map(
+      vs.getprop(setup.data, "existing.${entity.name}")))
+    local ${entity.name}_ref01_data = nil
+    if #${entity.name}_ref01_data_raw > 0 then
+      ${entity.name}_ref01_data = helpers.to_map(${entity.name}_ref01_data_raw[1][2])
+    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(`function ${entity.name}_basic_setup(extra)
+  runner.load_env_local()
+
+  local entity_data_file = _test_dir .. "../../.sdk/test/entity/${entity.name}/${entity.Name}TestData.json"
+  local f = io.open(entity_data_file, "r")
+  if f == nil then
+    error("failed to read ${entity.name} test data: " .. entity_data_file)
+  end
+  local entity_data_source = f:read("*a")
+  f:close()
+
+  local entity_data = json.decode(entity_data_source)
+
+  local options = {}
+  options["entity"] = entity_data["existing"]
+
+  local client = sdk.test(options, extra)
+
+`)
+
+    // Generate idmap via vs.transform
+    Content(`  -- Generate idmap via transform.
+  local idmap = vs.transform(
+    { ${idnamesStr} },
+    {
+      ["\`$PACK\`"] = { "", {
+        ["\`$KEY\`"] = "\`$COPY\`",
+        ["\`$VAL\`"] = { "\`$FORMAT\`", "upper", "\`$COPY\`" },
+      }},
+    }
+  )
+
+`)
+
+    Content(`  local 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",
+  })
+
+  local idmap_resolved = helpers.to_map(
+    env["${PROJUPPER}_TEST_${entity.name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID"])
+  if idmap_resolved == nil then
+    idmap_resolved = helpers.to_map(idmap)
+  end
+`)
+
+    // Add aliases
+    for (const [key, val] of aliases) {
+      Content(`  if idmap_resolved["${key}"] == nil then
+    idmap_resolved["${key}"] = idmap_resolved["${val}"]
+  end
+`)
+    }
+
+    Content(`
+  if env["${PROJUPPER}_TEST_LIVE"] == "TRUE" then
+    local merged_opts = vs.merge({
+      {
+        apikey = env["${PROJUPPER}_APIKEY"],
+      },
+      extra or {},
+    })
+    client = sdk.new(helpers.to_map(merged_opts))
+  end
+
+  return {
+    client = client,
+    data = entity_data,
+    idmap = idmap_resolved,
+    env = env,
+    explain = env["${PROJUPPER}_TEST_EXPLAIN"] == "TRUE",
+    now = os.time() * 1000,
+  }
+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(`    local ${entvar} = client:${entity.Name}(nil)
+`)
+  }
+
+  if (hasDatvar) {
+    Content(`    ${datavar} = helpers.to_map(vs.getprop(
+      vs.getpath(setup.data, "new.${entity.name}"), "${ref}"))
+`)
+  } else {
+    Content(`    local ${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(`
+    local ${datavar}_result, err = ${entvar}:create(${datavar}, nil)
+    assert.is_nil(err)
+    ${datavar} = helpers.to_map(${datavar}_result)
+    assert.is_not_nil(${datavar})
+    assert.is_not_nil(${datavar}["id"])
+`)
+}
+
+
+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(`    local ${entvar} = client:${entity.Name}(nil)
+`)
+  }
+
+  const matchEntries = getMatchEntries(step)
+  if (matchEntries.length === 0) {
+    Content(`    local ${matchvar} = {}
+`)
+  } else {
+    Content(`    local ${matchvar} = {
+`)
+    for (const [key, val] of matchEntries) {
+      Content(`      ["${key}"] = setup.idmap["${val}"],
+`)
+    }
+    Content(`    }
+`)
+  }
+
+  Content(`
+    local ${listvar}_result, err = ${entvar}:list(${matchvar}, nil)
+    assert.is_nil(err)
+    assert.is_table(${listvar}_result)
+`)
+
+  // 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(`
+    local found_item = vs.select(
+      runner.entity_list_to_data(${listvar}_result),
+      { id = ${refDataVar}["id"] })
+    assert.is_false(vs.isempty(found_item))
+`)
+      } else if ('ItemNotExists' === validator.apply && hasRefData) {
+        const refDataVar = validRef + '_data'
+        Content(`
+    local not_found_item = vs.select(
+      runner.entity_list_to_data(${listvar}_result),
+      { id = ${refDataVar}["id"] })
+    assert.is_true(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(`    local ${entvar} = client:${entity.Name}(nil)
+`)
+  }
+  Content(`    local ${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(`
+    local ${markdefvar}_name = "${fieldname}"
+    local ${markdefvar}_value = "${fieldvalue}_" .. tostring(setup.now)
+    ${datavar}_up[${markdefvar}_name] = ${markdefvar}_value
+`)
+      }
+    }
+  }
+
+  Content(`
+    local ${resdatavar}_result, err = ${entvar}:update(${datavar}_up, nil)
+    assert.is_nil(err)
+    local ${resdatavar} = helpers.to_map(${resdatavar}_result)
+    assert.is_not_nil(${resdatavar})
+    assert.are.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.are.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(`    local ${entvar} = client:${entity.Name}(nil)
+`)
+  }
+  if (!hasSrcData) {
+    Content(`    local ${srcdatavar}_raw = vs.items(helpers.to_map(
+      vs.getprop(setup.data, "existing.${entity.name}")))
+    local ${srcdatavar} = nil
+    if #${srcdatavar}_raw > 0 then
+      ${srcdatavar} = helpers.to_map(${srcdatavar}_raw[1][2])
+    end
+`)
+  }
+  Content(`    local ${matchvar} = {
+      id = ${srcdatavar}["id"],
+    }
+    local ${datavar}_loaded, err = ${entvar}:load(${matchvar}, nil)
+    assert.is_nil(err)
+    local ${datavar}_load_result = helpers.to_map(${datavar}_loaded)
+    assert.is_not_nil(${datavar}_load_result)
+    assert.are.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(`    local ${entvar} = client:${entity.Name}(nil)
+`)
+  }
+  Content(`    local ${matchvar} = {
+      id = ${srcdatavar}["id"],
+    }
+    local _, err = ${entvar}:remove(${matchvar}, nil)
+    assert.is_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/lua/Test_lua.ts

@@ -0,0 +1,49 @@
+
+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_lua'
+import { TestDirect } from './TestDirect_lua'
+
+
+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(`-- ProjectName SDK exists test
+
+local sdk = require("${model.name}_sdk")
+
+describe("${model.const.Name}SDK", function()
+  it("should create test SDK", function()
+    local testsdk = sdk.test(nil, nil)
+    assert.is_not_nil(testsdk)
+  end)
+end)
+`)
+    })
+
+    each(model.main[KIT].entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity })
+      TestDirect({ target, entity })
+    })
+  })
+})
+
+
+export {
+  Test
+}

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

@@ -0,0 +1,147 @@
+-- ProjectName SDK EntityName entity
+
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local EntityNameEntity = {}
+EntityNameEntity.__index = EntityNameEntity
+
+
+function EntityNameEntity.new(client, entopts)
+  entopts = entopts or {}
+  if entopts["active"] == nil then
+    entopts["active"] = true
+  elseif entopts["active"] == false then
+    -- keep false
+  else
+    entopts["active"] = true
+  end
+
+  local self = setmetatable({}, EntityNameEntity)
+  self._name = "entityname"
+  self._client = client
+  self._utility = client:get_utility()
+  self._entopts = entopts
+  self._data = {}
+  self._match = {}
+
+  self._entctx = self._utility.make_context({
+    entity = self,
+    entopts = entopts,
+  }, client:get_root_ctx())
+
+  self._utility.feature_hook(self._entctx, "PostConstructEntity")
+
+  return self
+end
+
+
+function EntityNameEntity:get_name()
+  return self._name
+end
+
+
+function EntityNameEntity:make()
+  local opts = {}
+  for k, v in pairs(self._entopts) do
+    opts[k] = v
+  end
+  return EntityNameEntity.new(self._client, opts)
+end
+
+
+function EntityNameEntity:data_set(args)
+  if args ~= nil then
+    self._data = helpers.to_map(vs.clone(args)) or {}
+    self._utility.feature_hook(self._entctx, "SetData")
+  end
+end
+
+
+function EntityNameEntity:data_get()
+  self._utility.feature_hook(self._entctx, "GetData")
+  return vs.clone(self._data)
+end
+
+
+function EntityNameEntity:match_set(args)
+  if args ~= nil then
+    self._match = helpers.to_map(vs.clone(args)) or {}
+    self._utility.feature_hook(self._entctx, "SetMatch")
+  end
+end
+
+
+function EntityNameEntity:match_get()
+  self._utility.feature_hook(self._entctx, "GetMatch")
+  return vs.clone(self._match)
+end
+
+
+-- #LoadOp
+
+-- #ListOp
+
+-- #CreateOp
+
+-- #UpdateOp
+
+-- #RemoveOp
+
+
+function EntityNameEntity:_run_op(ctx, post_done)
+  local utility = self._utility
+
+  -- #PrePoint-Hook
+
+  local point, err = utility.make_point(ctx)
+  ctx.out["point"] = point
+  if err ~= nil then
+    return utility.make_error(ctx, err)
+  end
+
+  -- #PreSpec-Hook
+
+  local spec
+  spec, err = utility.make_spec(ctx)
+  ctx.out["spec"] = spec
+  if err ~= nil then
+    return utility.make_error(ctx, err)
+  end
+
+  -- #PreRequest-Hook
+
+  local resp
+  resp, err = utility.make_request(ctx)
+  ctx.out["request"] = resp
+  if err ~= nil then
+    return utility.make_error(ctx, err)
+  end
+
+  -- #PreResponse-Hook
+
+  local resp2
+  resp2, err = utility.make_response(ctx)
+  ctx.out["response"] = resp2
+  if err ~= nil then
+    return utility.make_error(ctx, err)
+  end
+
+  -- #PreResult-Hook
+
+  local result
+  result, err = utility.make_result(ctx)
+  ctx.out["result"] = result
+  if err ~= nil then
+    return utility.make_error(ctx, err)
+  end
+
+  -- #PreDone-Hook
+
+  post_done()
+
+  return utility.done(ctx)
+end
+
+
+return EntityNameEntity

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

@@ -0,0 +1,27 @@
+local vs = require("utility.struct.struct")
+local helpers = require("core.helpers")
+
+local entityCreateOp = {}
+
+-- EJECT-START
+
+function EntityNameEntity:create(reqdata, ctrl)
+  local utility = self._utility
+  local ctx = utility.make_context({
+    opname = "create",
+    ctrl = ctrl,
+    match = self._match,
+    data = self._data,
+    reqdata = reqdata,
+  }, self._entctx)
+
+  return self:_run_op(ctx, function()
+    if ctx.result ~= nil then
+      if ctx.result.resdata ~= nil then
+        self._data = helpers.to_map(vs.clone(ctx.result.resdata)) or {}
+      end
+    end
+  end)
+end
+
+-- EJECT-END