@voxgig/sdkgen 0.35.2 → 0.36.0

package/project/.sdk/src/cmp/php/TestEntity_php.ts

@@ -0,0 +1,484 @@
+
+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 + 'EntityTest.' + target.ext }, () => {
+
+    Content(`<?php
+declare(strict_types=1);
+
+// ${entity.Name} entity test
+
+require_once __DIR__ . '/../${model.name}_sdk.php';
+require_once __DIR__ . '/Runner.php';
+
+use PHPUnit\\Framework\\TestCase;
+use Voxgig\\Struct\\Struct as Vs;
+
+class ${entity.Name}EntityTest extends TestCase
+{
+    public function test_create_instance(): void
+    {
+        $testsdk = ${model.const.Name}SDK::test(null, null);
+        $ent = $testsdk->${entity.Name}(null);
+        $this->assertNotNull($ent);
+    }
+
+    public function test_basic_flow(): void
+    {
+        $setup = ${entity.name}_basic_setup(null);
+        $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 = null;
+        if (count($${entity.name}_ref01_data_raw) > 0) {
+            $${entity.name}_ref01_data = Helpers::to_map($${entity.name}_ref01_data_raw[0][1]);
+        }
+
+`)
+    }
+
+    // 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(`    }
+}
+
+`)
+
+    // Generate setup function
+    Content(`function ${entity.name}_basic_setup($extra)
+{
+    Runner::load_env_local();
+
+    $entity_data_file = __DIR__ . '/../../.sdk/test/entity/${entity.name}/${entity.Name}TestData.json';
+    $entity_data_source = file_get_contents($entity_data_file);
+    $entity_data = json_decode($entity_data_source, true);
+
+    $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 === null) {
+        $idmap_resolved = Helpers::to_map($idmap);
+    }
+`)
+
+    // Add aliases
+    for (const [key, val] of aliases) {
+      Content(`    if (!isset($idmap_resolved["${key}"])) {
+        $idmap_resolved["${key}"] = $idmap_resolved["${val}"];
+    }
+`)
+    }
+
+    Content(`
+    if ($env["${PROJUPPER}_TEST_LIVE"] === "TRUE") {
+        $merged_opts = Vs::merge([
+            [
+                "apikey" => $env["${PROJUPPER}_APIKEY"],
+            ],
+            $extra ?? [],
+        ]);
+        $client = new ${model.const.Name}SDK(Helpers::to_map($merged_opts));
+    }
+
+    return [
+        "client" => $client,
+        "data" => $entity_data,
+        "idmap" => $idmap_resolved,
+        "env" => $env,
+        "explain" => $env["${PROJUPPER}_TEST_EXPLAIN"] === "TRUE",
+        "now" => (int)(microtime(true) * 1000),
+    ];
+}
+`)
+  })
+})
+
+
+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}(null);
+`)
+  }
+
+  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}, null);
+        $this->assertNull($err);
+        $${datavar} = Helpers::to_map($${datavar}_result);
+        $this->assertNotNull($${datavar});
+        $this->assertNotNull($${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(`        $${entvar} = $client->${entity.Name}(null);
+`)
+  }
+
+  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}, null);
+        $this->assertNull($err);
+        $this->assertIsArray($${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(`
+        $found_item = Vs::select(
+            Runner::entity_list_to_data($${listvar}_result),
+            ["id" => $${refDataVar}["id"]]);
+        $this->assertFalse(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"]]);
+        $this->assertTrue(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}(null);
+`)
+  }
+  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, null);
+        $this->assertNull($err);
+        $${resdatavar} = Helpers::to_map($${resdatavar}_result);
+        $this->assertNotNull($${resdatavar});
+        $this->assertEquals($${resdatavar}["id"], $${datavar}_up["id"]);
+`)
+
+  if (step.spec) {
+    for (const spec of step.spec) {
+      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+        Content(`        $this->assertEquals($${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}(null);
+`)
+  }
+  if (!hasSrcData) {
+    Content(`        $${srcdatavar}_raw = Vs::items(Helpers::to_map(
+            Vs::getprop($setup["data"], "existing.${entity.name}")));
+        $${srcdatavar} = null;
+        if (count($${srcdatavar}_raw) > 0) {
+            $${srcdatavar} = Helpers::to_map($${srcdatavar}_raw[0][1]);
+        }
+`)
+  }
+  Content(`        $${matchvar} = [
+            "id" => $${srcdatavar}["id"],
+        ];
+        [$${datavar}_loaded, $err] = $${entvar}->load($${matchvar}, null);
+        $this->assertNull($err);
+        $${datavar}_load_result = Helpers::to_map($${datavar}_loaded);
+        $this->assertNotNull($${datavar}_load_result);
+        $this->assertEquals($${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}(null);
+`)
+  }
+  Content(`        $${matchvar} = [
+            "id" => $${srcdatavar}["id"],
+        ];
+        [$_, $err] = $${entvar}->remove($${matchvar}, null);
+        $this->assertNull($err);
+`)
+}
+
+
+const GENERATE_OP: Record<string, OpGen> = {
+  create: generateCreate,
+  list: generateList,
+  update: generateUpdate,
+  load: generateLoad,
+  remove: generateRemove,
+}
+
+
+export {
+  TestEntity
+}

package/project/.sdk/src/cmp/php/Test_php.ts

@@ -0,0 +1,56 @@
+
+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_php'
+import { TestDirect } from './TestDirect_php'
+
+
+const Test = cmp(function Test(props: any) {
+  const { model, stdrep } = props.ctx$
+  const { target } = props
+
+  Folder({ name: 'test' }, () => {
+
+    // Generate exists test
+    File({ name: 'ExistsTest.' + target.ext }, () => {
+      Content(`<?php
+declare(strict_types=1);
+
+// ${model.const.Name} SDK exists test
+
+require_once __DIR__ . '/../${model.name}_sdk.php';
+
+use PHPUnit\\Framework\\TestCase;
+
+class ExistsTest extends TestCase
+{
+    public function test_create_test_sdk(): void
+    {
+        $testsdk = ${model.const.Name}SDK::test(null, null);
+        $this->assertNotNull($testsdk);
+    }
+}
+`)
+    })
+
+    each(model.main[KIT].entity, (entity: ModelEntity) => {
+      TestEntity({ target, entity })
+      TestDirect({ target, entity })
+    })
+  })
+})
+
+
+export {
+  Test
+}

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

@@ -0,0 +1,146 @@
+<?php
+declare(strict_types=1);
+
+// ProjectName SDK EntityName entity
+
+require_once __DIR__ . '/../utility/struct/Struct.php';
+require_once __DIR__ . '/../core/Helpers.php';
+
+use Voxgig\Struct\Struct;
+
+class EntityNameEntity
+{
+    private string $_name;
+    private $_client;
+    private $_utility;
+    private array $_entopts;
+    private array $_data;
+    private array $_match;
+    private $_entctx;
+
+    public function __construct($client, ?array $entopts = null)
+    {
+        $entopts = $entopts ?? [];
+        if (!isset($entopts["active"])) {
+            $entopts["active"] = true;
+        } elseif ($entopts["active"] === false) {
+            // keep false
+        } else {
+            $entopts["active"] = true;
+        }
+
+        $this->_name = "entityname";
+        $this->_client = $client;
+        $this->_utility = $client->get_utility();
+        $this->_entopts = $entopts;
+        $this->_data = [];
+        $this->_match = [];
+
+        $this->_entctx = ($this->_utility->make_context)([
+            "entity" => $this,
+            "entopts" => $entopts,
+        ], $client->get_root_ctx());
+
+        ($this->_utility->feature_hook)($this->_entctx, "PostConstructEntity");
+    }
+
+    public function get_name(): string
+    {
+        return $this->_name;
+    }
+
+    public function make(): self
+    {
+        $opts = $this->_entopts;
+        return new EntityNameEntity($this->_client, $opts);
+    }
+
+    public function data_set($args): void
+    {
+        if ($args) {
+            $this->_data = ProjectNameHelpers::to_map(Struct::clone($args)) ?? [];
+            ($this->_utility->feature_hook)($this->_entctx, "SetData");
+        }
+    }
+
+    public function data_get()
+    {
+        ($this->_utility->feature_hook)($this->_entctx, "GetData");
+        return Struct::clone($this->_data);
+    }
+
+    public function match_set($args): void
+    {
+        if ($args) {
+            $this->_match = ProjectNameHelpers::to_map(Struct::clone($args)) ?? [];
+            ($this->_utility->feature_hook)($this->_entctx, "SetMatch");
+        }
+    }
+
+    public function match_get()
+    {
+        ($this->_utility->feature_hook)($this->_entctx, "GetMatch");
+        return Struct::clone($this->_match);
+    }
+
+    // #LoadOp
+
+    // #ListOp
+
+    // #CreateOp
+
+    // #UpdateOp
+
+    // #RemoveOp
+
+    private function _run_op($ctx, callable $post_done): array
+    {
+        $utility = $this->_utility;
+
+        // #PrePoint-Hook
+
+        [$point, $err] = ($utility->make_point)($ctx);
+        $ctx->out["point"] = $point;
+        if ($err) {
+            return ($utility->make_error)($ctx, $err);
+        }
+
+        // #PreSpec-Hook
+
+        [$spec, $err] = ($utility->make_spec)($ctx);
+        $ctx->out["spec"] = $spec;
+        if ($err) {
+            return ($utility->make_error)($ctx, $err);
+        }
+
+        // #PreRequest-Hook
+
+        [$resp, $err] = ($utility->make_request)($ctx);
+        $ctx->out["request"] = $resp;
+        if ($err) {
+            return ($utility->make_error)($ctx, $err);
+        }
+
+        // #PreResponse-Hook
+
+        [$resp2, $err] = ($utility->make_response)($ctx);
+        $ctx->out["response"] = $resp2;
+        if ($err) {
+            return ($utility->make_error)($ctx, $err);
+        }
+
+        // #PreResult-Hook
+
+        [$result, $err] = ($utility->make_result)($ctx);
+        $ctx->out["result"] = $result;
+        if ($err) {
+            return ($utility->make_error)($ctx, $err);
+        }
+
+        // #PreDone-Hook
+
+        $post_done();
+
+        return ($utility->done)($ctx);
+    }
+}

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

@@ -0,0 +1,26 @@
+require_once __DIR__ . '/../utility/struct/Struct.php';
+require_once __DIR__ . '/../core/Helpers.php';
+
+// EJECT-START
+
+    public function create($reqdata, $ctrl = null): array
+    {
+        $utility = $this->_utility;
+        $ctx = ($utility->make_context)([
+            "opname" => "create",
+            "ctrl" => $ctrl,
+            "match" => $this->_match,
+            "data" => $this->_data,
+            "reqdata" => $reqdata,
+        ], $this->_entctx);
+
+        return $this->_run_op($ctx, function () use ($ctx) {
+            if ($ctx->result) {
+                if ($ctx->result->resdata) {
+                    $this->_data = ProjectNameHelpers::to_map(Struct::clone($ctx->result->resdata)) ?? [];
+                }
+            }
+        });
+    }
+
+// EJECT-END