@voxgig/sdkgen 0.25.0 → 0.28.0

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

@@ -0,0 +1,373 @@
+
+import {
+  Content,
+  File,
+  cmp,
+} from '@voxgig/sdkgen'
+
+
+const TestDirect = cmp(function TestDirect(props: any) {
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+
+  const target = props.target
+  const entity = props.entity
+  const gomodule = props.gomodule
+
+  const PROJECTNAME = model.Name.toUpperCase()
+
+  const opnames = Object.keys(entity.op)
+  const hasLoad = opnames.includes('load')
+  const hasList = opnames.includes('list')
+
+  if (!hasLoad && !hasList) {
+    return
+  }
+
+  const loadOp = entity.op.load
+  const listOp = entity.op.list
+
+  // Get load target info
+  const loadTarget = loadOp?.targets?.[0]
+  const loadPath = loadTarget ? (loadTarget.parts || []).join('/') : ''
+  const loadParams = loadTarget?.args?.params || []
+
+  // Get list target info
+  const listTarget = listOp?.targets?.[0]
+  const listPath = listTarget ? (listTarget.parts || []).join('/') : ''
+  const listParams = listTarget?.args?.params || []
+
+  // Build the ENTID env var name for this entity
+  const entidEnvVar = `${PROJECTNAME}_TEST_${entity.Name.toUpperCase()}_ENTID`
+
+  File({ name: entity.name + '_direct_test.' + target.ext }, () => {
+
+    Content(`package sdktest
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	sdk "${gomodule}"
+	"${gomodule}/core"
+)
+
+func Test${entity.Name}Direct(t *testing.T) {
+`)
+
+    // Generate list test first (load needs list results in live mode)
+    if (hasList && listTarget) {
+      const listParamStr = listParams.length > 0
+        ? listParams.map((p: any, i: number) =>
+          `"${p.name}": "direct0${i + 1}"`).join(', ')
+        : ''
+
+      // Build live params for list
+      const listLiveParams = listParams.map((p: any) => {
+        const key = p.name === 'id'
+          ? entity.name + '01'
+          : p.name.replace(/_id$/, '') + '01'
+        return { name: p.name, key }
+      })
+
+      Content(`	t.Run("direct-list-${entity.name}", func(t *testing.T) {
+		setup := ${entity.name}DirectSetup([]any{
+			map[string]any{"id": "direct01"},
+			map[string]any{"id": "direct02"},
+		})
+		client := setup.client
+
+`)
+
+      if (listParams.length > 0) {
+        Content(`		params := map[string]any{}
+`)
+        for (const lp of listLiveParams) {
+          Content(`		if setup.live {
+			params["${lp.name}"] = setup.idmap["${lp.key}"]
+		} else {
+			params["${lp.name}"] = "direct01"
+		}
+`)
+        }
+        Content(`
+		result, err := client.Direct(map[string]any{
+			"path":   "${listPath}",
+			"method": "GET",
+			"params": params,
+		})
+`)
+      } else {
+        Content(`
+		result, err := client.Direct(map[string]any{
+			"path":   "${listPath}",
+			"method": "GET",
+			"params": map[string]any{${listParamStr}},
+		})
+`)
+      }
+
+      Content(`		if err != nil {
+			t.Fatalf("direct failed: %v", err)
+		}
+
+		if result["ok"] != true {
+			t.Fatalf("expected ok to be true, got %v", result["ok"])
+		}
+		if core.ToInt(result["status"]) != 200 {
+			t.Fatalf("expected status 200, got %v", result["status"])
+		}
+
+		if !setup.live {
+			if dataList, ok := result["data"].([]any); ok {
+				if len(dataList) != 2 {
+					t.Fatalf("expected 2 items, got %d", len(dataList))
+				}
+			} else {
+				t.Fatalf("expected data to be an array, got %T", result["data"])
+			}
+
+			if len(*setup.calls) != 1 {
+				t.Fatalf("expected 1 call, got %d", len(*setup.calls))
+			}
+`)
+
+      if (listParams.length > 0) {
+        Content(`			call := (*setup.calls)[0]
+			if initMap, ok := call["init"].(map[string]any); ok {
+				if initMap["method"] != "GET" {
+					t.Fatalf("expected method GET, got %v", initMap["method"])
+				}
+			}
+			if url, ok := call["url"].(string); ok {
+`)
+        for (let i = 0; i < listParams.length; i++) {
+          Content(`				if !strings.Contains(url, "direct0${i + 1}") {
+					t.Fatalf("expected url to contain direct0${i + 1}, got %v", url)
+				}
+`)
+        }
+        Content(`			}
+`)
+      }
+
+      Content(`		}
+	})
+
+`)
+    }
+
+    // Generate load test - in live mode, first list to get a real entity ID
+    if (hasLoad && loadTarget) {
+      const loadParamStr = loadParams.length > 0
+        ? loadParams.map((p: any, i: number) =>
+          `"${p.name}": "direct0${i + 1}"`).join(', ')
+        : ''
+
+      // Identify ancestor params (not 'id') for live mode
+      const ancestorParams = loadParams.filter((p: any) => p.name !== 'id')
+
+      Content(`	t.Run("direct-load-${entity.name}", func(t *testing.T) {
+		setup := ${entity.name}DirectSetup(map[string]any{"id": "direct01"})
+		client := setup.client
+
+`)
+
+      if (loadParams.length > 0) {
+        Content(`		params := map[string]any{}
+`)
+
+        Content(`		if setup.live {
+`)
+
+        // In live mode: first list to get a real entity, then use its ID
+        if (hasList) {
+          // Build list params from idmap
+          Content(`			listParams := map[string]any{}
+`)
+          for (const p of listParams) {
+            const key = p.name === 'id'
+              ? entity.name + '01'
+              : p.name.replace(/_id$/, '') + '01'
+            Content(`			listParams["${p.name}"] = setup.idmap["${key}"]
+`)
+          }
+
+          Content(`			listResult, listErr := client.Direct(map[string]any{
+				"path":   "${listPath}",
+				"method": "GET",
+				"params": listParams,
+			})
+			if listErr != nil {
+				t.Fatalf("list for load setup failed: %v", listErr)
+			}
+			if listResult["ok"] != true {
+				t.Fatalf("list for load setup not ok: %v", listResult)
+			}
+
+			// Get first entity ID from list
+			listData, _ := listResult["data"].([]any)
+			if len(listData) == 0 {
+				t.Skip("no entities to load in live mode")
+			}
+			firstEnt := core.ToMapAny(listData[0])
+			params["id"] = firstEnt["id"]
+`)
+          // Set ancestor params from idmap
+          for (const p of ancestorParams) {
+            const key = p.name.replace(/_id$/, '') + '01'
+            Content(`			params["${p.name}"] = setup.idmap["${key}"]
+`)
+          }
+        }
+
+        Content(`		} else {
+`)
+        for (let i = 0; i < loadParams.length; i++) {
+          Content(`			params["${loadParams[i].name}"] = "direct0${i + 1}"
+`)
+        }
+        Content(`		}
+`)
+      }
+
+      Content(`
+		result, err := client.Direct(map[string]any{
+			"path":   "${loadPath}",
+			"method": "GET",
+`)
+      if (loadParams.length > 0) {
+        Content(`			"params": params,
+`)
+      } else {
+        Content(`			"params": map[string]any{},
+`)
+      }
+      Content(`		})
+		if err != nil {
+			t.Fatalf("direct failed: %v", err)
+		}
+
+		if result["ok"] != true {
+			t.Fatalf("expected ok to be true, got %v", result["ok"])
+		}
+		if core.ToInt(result["status"]) != 200 {
+			t.Fatalf("expected status 200, got %v", result["status"])
+		}
+		if result["data"] == nil {
+			t.Fatal("expected data to be non-nil")
+		}
+
+		if !setup.live {
+			if dataMap, ok := result["data"].(map[string]any); ok {
+				if dataMap["id"] != "direct01" {
+					t.Fatalf("expected data.id to be direct01, got %v", dataMap["id"])
+				}
+			}
+
+			if len(*setup.calls) != 1 {
+				t.Fatalf("expected 1 call, got %d", len(*setup.calls))
+			}
+			call := (*setup.calls)[0]
+			if initMap, ok := call["init"].(map[string]any); ok {
+				if initMap["method"] != "GET" {
+					t.Fatalf("expected method GET, got %v", initMap["method"])
+				}
+			}
+			if url, ok := call["url"].(string); ok {
+`)
+
+      for (let i = 0; i < loadParams.length; i++) {
+        Content(`				if !strings.Contains(url, "direct0${i + 1}") {
+					t.Fatalf("expected url to contain direct0${i + 1}, got %v", url)
+				}
+`)
+      }
+
+      Content(`			}
+		}
+	})
+
+`)
+    }
+
+    Content(`}
+
+type ${entity.name}DirectSetupResult struct {
+	client *sdk.${model.const.Name}SDK
+	calls  *[]map[string]any
+	live   bool
+	idmap  map[string]any
+}
+
+func ${entity.name}DirectSetup(mockres any) *${entity.name}DirectSetupResult {
+	loadEnvLocal()
+
+	calls := &[]map[string]any{}
+
+	env := envOverride(map[string]any{
+		"${entidEnvVar}": map[string]any{},
+		"${PROJECTNAME}_TEST_LIVE":    "FALSE",
+		"${PROJECTNAME}_APIKEY":       "NONE",
+	})
+
+	live := env["${PROJECTNAME}_TEST_LIVE"] == "TRUE"
+
+	if live {
+		mergedOpts := map[string]any{
+			"apikey": env["${PROJECTNAME}_APIKEY"],
+		}
+		client := sdk.New${model.const.Name}SDK(mergedOpts)
+
+		idmap := map[string]any{}
+		if entidRaw, ok := env["${entidEnvVar}"]; ok {
+			if entidStr, ok := entidRaw.(string); ok && strings.HasPrefix(entidStr, "{") {
+				json.Unmarshal([]byte(entidStr), &idmap)
+			} else if entidMap, ok := entidRaw.(map[string]any); ok {
+				idmap = entidMap
+			}
+		}
+
+		return &${entity.name}DirectSetupResult{client: client, calls: calls, live: true, idmap: idmap}
+	}
+
+	mockFetch := func(url string, init map[string]any) (map[string]any, error) {
+		*calls = append(*calls, map[string]any{"url": url, "init": init})
+		return map[string]any{
+			"status":     200,
+			"statusText": "OK",
+			"headers":    map[string]any{},
+			"json": (func() any)(func() any {
+				if mockres != nil {
+					return mockres
+				}
+				return map[string]any{"id": "direct01"}
+			}),
+		}, nil
+	}
+
+	client := sdk.New${model.const.Name}SDK(map[string]any{
+		"base": "http://localhost:8080",
+		"system": map[string]any{
+			"fetch": (func(string, map[string]any) (map[string]any, error))(mockFetch),
+		},
+	})
+
+	return &${entity.name}DirectSetupResult{client: client, calls: calls, live: false, idmap: map[string]any{}}
+}
+`)
+
+    // Suppress unused import warnings
+    Content(`
+var _ = os.Getenv
+var _ = json.Unmarshal
+`)
+  })
+})
+
+
+export {
+  TestDirect
+}

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

@@ -0,0 +1,341 @@
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+import {
+  Content,
+  File,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const ctx$ = props.ctx$
+  const model = ctx$.model
+
+  const target = props.target
+  const entity = props.entity
+  const gomodule = props.gomodule
+
+  const basicflow = getModelPath(model, `main.${KIT}.flow.Basic${entity.Name}Flow`)
+  const dobasic = basicflow && true === basicflow.active
+
+  if (!dobasic) {
+    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 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()
+  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[] = []
+  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}`)
+  }
+
+  // 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)
+
+  // Get update data entries (non-id, non-$ keys)
+  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(', ')
+
+  File({ name: entity.name + '_entity_test.' + target.ext }, () => {
+
+    Content(`package sdktest
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	sdk "${gomodule}"
+	"${gomodule}/core"
+
+	vs "github.com/voxgig/struct"
+)
+
+func Test${entity.Name}Entity(t *testing.T) {
+	t.Run("instance", func(t *testing.T) {
+		testsdk := sdk.TestSDK(nil, nil)
+		ent := testsdk.${entity.Name}(nil)
+		if ent == nil {
+			t.Fatal("expected non-nil ${entity.Name}Entity")
+		}
+	})
+
+	t.Run("basic", func(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")
+		}
+
+		// 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}"],
+`)
+      }
+      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")
+		}
+	})
+}
+
+`)
+
+    // Generate setup function
+    Content(`func ${entity.name}BasicSetup(extra map[string]any) *entityTestSetup {
+	loadEnvLocal()
+
+	_, filename, _, _ := runtime.Caller(0)
+	dir := filepath.Dir(filename)
+
+	entityDataFile := filepath.Join(dir, "..", "..", ".sdk", "test", "entity", "${entity.name}", "${entity.Name}TestData.json")
+
+	entityDataSource, err := os.ReadFile(entityDataFile)
+	if err != nil {
+		panic("failed to read ${entity.name} test data: " + err.Error())
+	}
+
+	var entityData map[string]any
+	if err := json.Unmarshal(entityDataSource, &entityData); err != nil {
+		panic("failed to parse ${entity.name} test data: " + err.Error())
+	}
+
+	options := map[string]any{}
+	options["entity"] = entityData["existing"]
+
+	client := sdk.TestSDK(options, extra)
+
+`)
+
+    // Generate idmap via vs.Transform
+    Content('\t// Generate idmap via transform, matching TS pattern.\n')
+    Content('\tidmap := vs.Transform(\n')
+    Content('\t\t[]any{' + idnamesStr + '},\n')
+    Content('\t\tmap[string]any{\n')
+    Content('\t\t\t"`$PACK`": []any{"", map[string]any{\n')
+    Content('\t\t\t\t"`$KEY`": "`$COPY`",\n')
+    Content('\t\t\t\t"`$VAL`": []any{"`$FORMAT`", "upper", "`$COPY`"},\n')
+    Content('\t\t\t}},\n')
+    Content('\t\t},\n')
+    Content('\t)\n')
+
+    Content(`
+	env := envOverride(map[string]any{
+		"${PROJUPPER}_TEST_${entity.name.toUpperCase()}_ENTID": idmap,
+		"${PROJUPPER}_TEST_LIVE":      "FALSE",
+		"${PROJUPPER}_TEST_EXPLAIN":   "FALSE",
+		"${PROJUPPER}_APIKEY":         "NONE",
+	})
+
+	idmapResolved := core.ToMapAny(env["${PROJUPPER}_TEST_${entity.name.toUpperCase()}_ENTID"])
+	if idmapResolved == nil {
+		idmapResolved = core.ToMapAny(idmap)
+	}
+`)
+
+    // Add aliases for ancestor field names
+    for (const [key, val] of aliases) {
+      Content(`	// Add ${key} alias for update test.
+	if idmapResolved["${key}"] == nil {
+		idmapResolved["${key}"] = idmapResolved["${val}"]
+	}
+`)
+    }
+
+    Content(`
+	if env["${PROJUPPER}_TEST_LIVE"] == "TRUE" {
+		mergedOpts := vs.Merge([]any{
+			map[string]any{
+				"apikey": env["${PROJUPPER}_APIKEY"],
+			},
+			extra,
+		})
+		client = sdk.New${model.const.Name}SDK(core.ToMapAny(mergedOpts))
+	}
+
+	return &entityTestSetup{
+		client:  client,
+		data:    entityData,
+		idmap:   idmapResolved,
+		env:     env,
+		explain: env["${PROJUPPER}_TEST_EXPLAIN"] == "TRUE",
+		now:     time.Now().UnixMilli(),
+	}
+}
+`)
+  })
+})
+
+
+export {
+  TestEntity
+}