@voxgig/sdkgen 0.35.2 → 0.36.0

package/project/.sdk/src/cmp/go/TestEntity_go.ts

@@ -1,4 +1,10 @@
 
+import {
+  flatten,
+  items,
+  join,
+} from '@voxgig/struct'
+
 import {
   KIT,
   getModelPath,
@@ -13,6 +19,23 @@ import {
 } from '@voxgig/sdkgen'
 
 
+// Convert snake_case to camelCase for Go variable names.
+function goVar(name: string): string {
+  return name.replace(/_([a-z0-9])/g, (_: any, c: string) => c.toUpperCase())
+}
+
+
+type OpGen = (ctx: GenCtx, step: any, index: any) => void
+
+type GenCtx = {
+  model: any
+  entity: any
+  gomodule: string
+  flow: any
+  PROJUPPER: string
+}
+
+
 const TestEntity = cmp(function TestEntity(props: any) {
   const ctx$ = props.ctx$
   const model = ctx$.model
@@ -28,20 +51,9 @@ const TestEntity = cmp(function TestEntity(props: any) {
     return
   }
 
-  const steps = basicflow.step || []
-  const createStep = steps.find((s: any) => s.op === 'create')
-  const updateStep = steps.find((s: any) => s.op === 'update')
-  const listSteps = steps.filter((s: any) => s.op === 'list')
-  const firstListStep = listSteps[0]
-  const lastListStep = listSteps[listSteps.length - 1]
+  const PROJUPPER = model.const.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
 
-  const ref = createStep?.input?.ref || entity.name + '_ref01'
-  // Convert snake_case ref to camelCase for Go variable names
-  const refVar = ref.replace(/_([a-z0-9])/g, (_: any, c: string) => c.toUpperCase())
   const ancestors = (entity.relations?.ancestors || []).flat()
-  const PROJUPPER = model.const.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
-  const textfield = updateStep?.input?.textfield || 'kind'
-  const mark = updateStep?.spec?.[0]?.def?.mark || `Mark01-${ref}`
 
   // Build idmap names: entity's own + ancestor ids
   const idnames: string[] = []
@@ -50,25 +62,17 @@ const TestEntity = cmp(function TestEntity(props: any) {
     for (let i = 1; i <= 3; i++) idnames.push(`${anc}0${i}`)
   }
 
-  // Get match entries from flow steps (filter out $ keys)
-  const getMatch = (step: any) => {
-    if (!step?.match) return []
-    return Object.entries(step.match).filter(([k]: any) => !k.endsWith('$'))
-  }
-
-  const createMatch = getMatch(createStep)
-  const firstListMatch = getMatch(firstListStep)
-  const lastListMatch = getMatch(lastListStep)
+  const idnamesStr = idnames.map(n => `"${n}"`).join(', ')
 
-  // Get update data entries (non-id, non-$ keys)
+  // Get all update data entries for alias generation
+  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('$'))
     : []
-
-  // Aliases needed from update data entries
   const aliases = updateData.map(([k, v]: any) => [k, v])
 
-  const idnamesStr = idnames.map(n => `"${n}"`).join(', ')
+  const genCtx: GenCtx = { model, entity, gomodule, flow: basicflow, PROJUPPER }
 
   File({ name: entity.name + '_entity_test.' + target.ext }, () => {
 
@@ -102,150 +106,32 @@ func Test${entity.Name}Entity(t *testing.T) {
 		setup := ${entity.name}BasicSetup(nil)
 		client := setup.client
 
-		// CREATE
-		${entity.name}Ent := client.${entity.Name}(nil)
-		${refVar}Data := core.ToMapAny(vs.GetProp(
-			vs.GetPath([]any{"new", "${entity.name}"}, setup.data), "${ref}"))
-`)
-
-    // Add create match entries
-    for (const [key, val] of createMatch) {
-      Content(`		${refVar}Data["${key}"] = setup.idmap["${val}"]
-`)
-    }
-
-    Content(`
-		createResult, err := ${entity.name}Ent.Create(${refVar}Data, nil)
-		if err != nil {
-			t.Fatalf("create failed: %v", err)
-		}
-		createData := core.ToMapAny(createResult)
-		if createData == nil {
-			t.Fatal("expected create result to be a map")
-		}
-		if createData["id"] == nil {
-			t.Fatal("expected created entity to have an id")
-		}
-
-		// LIST
-`)
-
-    // Generate list match map
-    if (firstListMatch.length === 0) {
-      Content(`		${refVar}Match := map[string]any{}
-`)
-    } else {
-      Content(`		${refVar}Match := map[string]any{
-`)
-      for (const [key, val] of firstListMatch) {
-        Content(`			"${key}": setup.idmap["${val}"],
 `)
-      }
-      Content(`		}
-`)
-    }
-
-    Content(`		listResult, err := ${entity.name}Ent.List(${refVar}Match, nil)
-		if err != nil {
-			t.Fatalf("list failed: %v", err)
-		}
-		listData, ok := listResult.([]any)
-		if !ok {
-			t.Fatalf("expected list result to be an array, got %T", listResult)
-		}
 
-		found := vs.Select(entityListToData(listData), map[string]any{"id": createData["id"]})
-		if vs.IsEmpty(found) {
-			t.Fatal("expected to find created entity in list")
+    // Check if the flow has a create step; if not, bootstrap entity data
+    const flowHasCreate = allSteps.some((s: any) => s.op === 'create')
+    if (!flowHasCreate) {
+      const preambleRef = entity.name + '_ref01'
+      Content(`		// Bootstrap entity data from existing test data (no create step in flow).
+		${goVar(preambleRef)}DataRaw := vs.Items(core.ToMapAny(vs.GetProp(setup.data, "existing.${entity.name}")))
+		var ${goVar(preambleRef)}Data map[string]any
+		if len(${goVar(preambleRef)}DataRaw) > 0 {
+			${goVar(preambleRef)}Data = core.ToMapAny(${goVar(preambleRef)}DataRaw[0][1])
 		}
 
-		// UPDATE
-		markValue := fmt.Sprintf("${mark}_%d", setup.now)
-		${refVar}DataUp := map[string]any{
-			"id":   createData["id"],
-`)
-
-    // Add update data entries
-    for (const [key] of updateData) {
-      Content(`			"${key}": setup.idmap["${key}"],
 `)
     }
 
-    Content(`			"${textfield}": markValue,
-		}
-
-		updateResult, err := ${entity.name}Ent.Update(${refVar}DataUp, nil)
-		if err != nil {
-			t.Fatalf("update failed: %v", err)
-		}
-		updateData := core.ToMapAny(updateResult)
-		if updateData == nil {
-			t.Fatal("expected update result to be a map")
-		}
-		if updateData["id"] != createData["id"] {
-			t.Fatal("expected update result id to match")
-		}
-		if updateData["${textfield}"] != markValue {
-			t.Fatalf("expected ${textfield} to be updated, got %v", updateData["${textfield}"])
-		}
-
-		// LOAD
-		${refVar}MatchDt := map[string]any{
-			"id": createData["id"],
-		}
-		loadResult, err := ${entity.name}Ent.Load(${refVar}MatchDt, nil)
-		if err != nil {
-			t.Fatalf("load failed: %v", err)
-		}
-		loadData := core.ToMapAny(loadResult)
-		if loadData == nil {
-			t.Fatal("expected load result to be a map")
-		}
-		if loadData["id"] != createData["id"] {
-			t.Fatal("expected load result id to match")
-		}
-
-		// REMOVE
-		${refVar}MatchRm := map[string]any{
-			"id": createData["id"],
-		}
-		_, err = ${entity.name}Ent.Remove(${refVar}MatchRm, nil)
-		if err != nil {
-			t.Fatalf("remove failed: %v", err)
-		}
-
-		// LIST (verify removed)
-`)
-
-    // Generate verify list match map
-    if (lastListMatch.length === 0) {
-      Content(`		${refVar}MatchRt := map[string]any{}
-`)
-    } else {
-      Content(`		${refVar}MatchRt := map[string]any{
-`)
-      for (const [key, val] of lastListMatch) {
-        Content(`			"${key}": setup.idmap["${val}"],
-`)
+    // 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(`		}
-`)
-    }
-
-    Content(`		listResult2, err := ${entity.name}Ent.List(${refVar}MatchRt, nil)
-		if err != nil {
-			t.Fatalf("list after remove failed: %v", err)
-		}
-		listData2, ok := listResult2.([]any)
-		if !ok {
-			t.Fatalf("expected list result to be an array, got %T", listResult2)
-		}
+    })
 
-		found2 := vs.Select(entityListToData(listData2), map[string]any{"id": createData["id"]})
-		if !vs.IsEmpty(found2) {
-			t.Fatal("expected removed entity to not be in list")
-		}
-	})
+    Content(`	})
 }
 
 `)
@@ -336,6 +222,320 @@ func Test${entity.Name}Entity(t *testing.T) {
 })
 
 
+// Get match entries from a step, filtering out $ keys.
+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 = goVar(step.input?.entvar ?? ref + '_ent')
+  const datavar = goVar(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 = goVar(s.input?.datavar ?? (priorRef + '_data' + (s.input?.suffix ?? '')))
+      return priorDatvar === datavar
+    }
+    return false
+  })
+
+  Content(`		// CREATE
+`)
+  if (needsEnt) {
+    Content(`		${entvar} := client.${entity.Name}(nil)
+`)
+  }
+
+  // Load data from test data file
+  if (hasDatvar) {
+    Content(`		${datavar} = core.ToMapAny(vs.GetProp(
+			vs.GetPath([]any{"new", "${entity.name}"}, setup.data), "${ref}"))
+`)
+  } else {
+    Content(`		${datavar} := core.ToMapAny(vs.GetProp(
+			vs.GetPath([]any{"new", "${entity.name}"}, setup.data), "${ref}"))
+`)
+  }
+
+  // Add match entries
+  const matchEntries = getMatchEntries(step)
+  for (const [key, val] of matchEntries) {
+    Content(`		${datavar}["${key}"] = setup.idmap["${val}"]
+`)
+  }
+
+  Content(`
+		${datavar}Result, err := ${entvar}.Create(${datavar}, nil)
+		if err != nil {
+			t.Fatalf("create failed: %v", err)
+		}
+		${datavar} = core.ToMapAny(${datavar}Result)
+		if ${datavar} == nil {
+			t.Fatal("expected create result to be a map")
+		}
+		if ${datavar}["id"] == nil {
+			t.Fatal("expected created entity to have an id")
+		}
+`)
+}
+
+
+const generateList: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  const ref = step.input?.ref ?? entity.name + '_ref01'
+  const entvar = goVar(step.input?.entvar ?? ref + '_ent')
+  const matchvar = goVar(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
+  const listvar = goVar(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)
+`)
+  }
+
+  // Generate match map
+  const matchEntries = getMatchEntries(step)
+  if (matchEntries.length === 0) {
+    Content(`		${matchvar} := map[string]any{}
+`)
+  } else {
+    Content(`		${matchvar} := map[string]any{
+`)
+    for (const [key, val] of matchEntries) {
+      Content(`			"${key}": setup.idmap["${val}"],
+`)
+    }
+    Content(`		}
+`)
+  }
+
+  Content(`
+		${listvar}Result, err := ${entvar}.List(${matchvar}, nil)
+		if err != nil {
+			t.Fatalf("list failed: %v", err)
+		}
+		${listvar}, ok := ${listvar}Result.([]any)
+		if !ok {
+			t.Fatalf("expected list result to be an array, got %T", ${listvar}Result)
+		}
+`)
+
+  // Handle validators from step.valid
+  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 = goVar(validRef + '_data')
+        Content(`
+		foundItem := vs.Select(entityListToData(${listvar}), map[string]any{"id": ${refDataVar}["id"]})
+		if vs.IsEmpty(foundItem) {
+			t.Fatal("expected to find created entity in list")
+		}
+`)
+      } else if ('ItemNotExists' === validator.apply && hasRefData) {
+        const refDataVar = goVar(validRef + '_data')
+        Content(`
+		notFoundItem := vs.Select(entityListToData(${listvar}), map[string]any{"id": ${refDataVar}["id"]})
+		if !vs.IsEmpty(notFoundItem) {
+			t.Fatal("expected removed entity to not be in list")
+		}
+`)
+      }
+    }
+  }
+}
+
+
+const generateUpdate: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  const ref = step.input?.ref ?? entity.name + '_ref01'
+  const entvar = goVar(step.input?.entvar ?? ref + '_ent')
+  const datavar = goVar(step.input?.datavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
+  const resdatavar = goVar(step.input?.resdatavar ?? (ref + '_resdata' + (step.input?.suffix ?? '')))
+  const markdefvar = goVar(step.input?.markdefvar ?? (ref + '_markdef' + (step.input?.suffix ?? '')))
+  const srcdatavar = goVar(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 := map[string]any{
+			"id": ${srcdatavar}["id"],
+`)
+
+  // Add data entries from step.data
+  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(`		}
+`)
+
+  // Handle TextFieldMark spec
+  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 := fmt.Sprintf("${fieldvalue}_%d", setup.now)
+		${datavar}Up[${markdefvar}Name] = ${markdefvar}Value
+`)
+      }
+    }
+  }
+
+  Content(`
+		${resdatavar}Result, err := ${entvar}.Update(${datavar}Up, nil)
+		if err != nil {
+			t.Fatalf("update failed: %v", err)
+		}
+		${resdatavar} := core.ToMapAny(${resdatavar}Result)
+		if ${resdatavar} == nil {
+			t.Fatal("expected update result to be a map")
+		}
+		if ${resdatavar}["id"] != ${datavar}Up["id"] {
+			t.Fatal("expected update result id to match")
+		}
+`)
+
+  // Assert TextFieldMark
+  if (step.spec) {
+    for (const spec of step.spec) {
+      if ('TextFieldMark' === spec.apply && null != step.input?.textfield) {
+        Content(`		if ${resdatavar}[${markdefvar}Name] != ${markdefvar}Value {
+			t.Fatalf("expected %s to be updated, got %v", ${markdefvar}Name, ${resdatavar}[${markdefvar}Name])
+		}
+`)
+      }
+    }
+  }
+}
+
+
+const generateLoad: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  const ref = step.input?.ref ?? entity.name + '_ref01'
+  const entvar = goVar(step.input?.entvar ?? ref + '_ent')
+  const matchvar = goVar(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
+  const datavar = goVar(step.input?.datavar ?? (ref + '_data' + (step.input?.suffix ?? '')))
+  const srcdatavar = goVar(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))
+
+  // Check if srcdatavar was declared by a prior create step or preamble
+  const flowHasCreate = Object.values(flow.step).some((s: any) => (s as any).op === 'create')
+  const preambleRef = entity.name + '_ref01'
+  const hasSrcData = (!flowHasCreate && srcdatavar === goVar(preambleRef + '_data')) ||
+    priorSteps.some((s: any) => {
+      if ('create' === s.op) {
+        const priorRef = s.input?.ref ?? entity.name + '_ref01'
+        const priorDatvar = goVar(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(core.ToMapAny(vs.GetProp(setup.data, "existing.${entity.name}")))
+		var ${srcdatavar} map[string]any
+		if len(${srcdatavar}Raw) > 0 {
+			${srcdatavar} = core.ToMapAny(${srcdatavar}Raw[0][1])
+		}
+`)
+  }
+  Content(`		${matchvar} := map[string]any{
+			"id": ${srcdatavar}["id"],
+		}
+		${datavar}Loaded, err := ${entvar}.Load(${matchvar}, nil)
+		if err != nil {
+			t.Fatalf("load failed: %v", err)
+		}
+		${datavar}LoadResult := core.ToMapAny(${datavar}Loaded)
+		if ${datavar}LoadResult == nil {
+			t.Fatal("expected load result to be a map")
+		}
+		if ${datavar}LoadResult["id"] != ${srcdatavar}["id"] {
+			t.Fatal("expected load result id to match")
+		}
+`)
+}
+
+
+const generateRemove: OpGen = (ctx, step, index) => {
+  const { entity, flow } = ctx
+  const ref = step.input?.ref ?? entity.name + '_ref01'
+  const entvar = goVar(step.input?.entvar ?? ref + '_ent')
+  const matchvar = goVar(step.input?.matchvar ?? (ref + '_match' + (step.input?.suffix ?? '')))
+  const srcdatavar = goVar(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} := map[string]any{
+			"id": ${srcdatavar}["id"],
+		}
+		_, err = ${entvar}.Remove(${matchvar}, nil)
+		if err != nil {
+			t.Fatalf("remove failed: %v", err)
+		}
+`)
+}
+
+
+const GENERATE_OP: Record<string, OpGen> = {
+  create: generateCreate,
+  list: generateList,
+  update: generateUpdate,
+  load: generateLoad,
+  remove: generateRemove,
+}
+
+
 export {
   TestEntity
 }

package/project/.sdk/src/cmp/go/Test_go.ts

@@ -8,7 +8,7 @@ import type {
   ModelEntity
 } from '@voxgig/apidef'
 
-import { cmp, each, Folder } from '@voxgig/sdkgen'
+import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
 
 
 import { TestEntity } from './TestEntity_go'
@@ -24,6 +24,29 @@ const Test = cmp(function Test(props: any) {
   const gomodule = orgPrefix + model.name + 'sdk'
 
   Folder({ name: 'test' }, () => {
+
+    // Generate exists_test.go programmatically to avoid duplication
+    // with any scaffolded test file (e.g. projectname_sdk_test.go).
+    File({ name: 'exists_test.' + target.ext }, () => {
+      Content(`package sdktest
+
+import (
+	"testing"
+
+	sdk "${gomodule}"
+)
+
+func TestExists(t *testing.T) {
+	t.Run("test-mode", func(t *testing.T) {
+		testsdk := sdk.TestSDK(nil, nil)
+		if testsdk == nil {
+			t.Fatal("expected non-nil SDK")
+		}
+	})
+}
+`)
+    })
+
     each(model.main[KIT].entity, (entity: ModelEntity) => {
       TestEntity({ target, entity, gomodule })
       TestDirect({ target, entity, gomodule })

package/project/.sdk/src/cmp/js/ReadmeQuick_js.ts

@@ -14,7 +14,7 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
   const entity = getModelPath(model, `main.${KIT}.entity`)
 
   // Find the first published entity for examples
-  const exampleEntity = Object.values(entity).find((e: any) => e.publish) as any
+  const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
   Content(`
 ### Create a Client