@voxgig/sdkgen 1.3.14 → 1.3.18

package/project/.sdk/src/cmp/lean/Test_lean.ts

@@ -0,0 +1,207 @@
+import {
+  Content,
+  File,
+  Folder,
+  cmp,
+  each,
+} from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  Model,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+// True when an op has at least one endpoint point that needs no path params
+// (a top-level operation the live smoke test can call without an id).
+function hasParamFreePoint(op: any): boolean {
+  if (null == op) return false
+  const points = op.points || []
+  for (const pt of points) {
+    const params = ((pt.args || {}).params) || []
+    if (params.length === 0) return true
+  }
+  return false
+}
+
+
+// Synthesize a create payload from the entity's required non-id fields.
+function synthData(fields: any): any {
+  const o: any = {}
+  each(fields, (f: any) => {
+    if (f.req && f.name !== 'id') {
+      const t = String(f.type || '').toLowerCase()
+      o[f.name] =
+        (t.includes('number') || t.includes('integer') || t.includes('decimal')) ? 42
+          : t.includes('bool') ? true
+            : 'leantest'
+    }
+  })
+  return o
+}
+
+
+// The generated `test/Runner.lean` exe runs TWO lanes:
+//
+//  - OFFLINE (always): a test-mode client seeded from the entity's generated
+//    `<Entity>TestData.json` answers operations from an in-memory store, so
+//    entity behaviour (list/load/create/load-back/remove) is verified with no
+//    server — the same guarantee the `test` feature gives the other targets.
+//  - LIVE (only when SDK_TEST_BASE is set): the same flow against a real
+//    server, exercising the curl transport end to end.
+const Test = cmp(async function Test(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+  const model: Model = ctx$.model
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+
+  // Per-entity OFFLINE (test-mode) blocks: seeded store, no server.
+  let offline = ''
+  each(entity, (e: any) => {
+    const ns = e.name.charAt(0).toUpperCase() + e.name.slice(1)
+    const Name = e.Name || (e.name.charAt(0).toUpperCase() + e.name.slice(1))
+    const ops = e.op || {}
+    if (!ops.list && !ops.load) return
+    offline += `    -- ${e.name}: offline (test-mode) entity behaviour
+    (do
+      let seedPath := "../.sdk/test/entity/${e.name}/${Name}TestData.json"
+      if !(← System.FilePath.pathExists seedPath) then
+        IO.println s!"skip - ${e.name}: no seed at {seedPath}"
+      else do
+        let seed ← SdkJson.jsonRead (← IO.FS.readFile seedPath)
+        let tclient ← Sdk.testSdk0 seed
+        let existing ← SdkRuntime.gp (← SdkRuntime.gp seed "existing") "${e.name}"
+        let ids ← keysof existing
+        -- list returns every seeded entity
+        let items ← ${ns}.list tclient (← emptyMap) (← emptyMap)
+        let n ← (match items with | .list lid => do pure (← listItems lid).size | _ => pure 0)
+        if n == ids.size then pass s!"${e.name}.list offline -> {n} seeded"
+        else fail s!"${e.name}.list offline: got {n}, want {ids.size}"
+        -- load the first seeded entity by id
+        if ids.size > 0 then do
+          let wid := ids[0]!
+          let m ← newMap #[("id", .str wid)]
+          let got ← ${ns}.load tclient m (← emptyMap)
+          let gid ← SdkRuntime.gpS got "id"
+          if gid == wid then pass s!"${e.name}.load offline (id={wid})"
+          else fail s!"${e.name}.load offline: got {gid}, want {wid}"
+        -- create -> load back -> remove, all in the store
+        let newmap ← SdkRuntime.gp (← SdkRuntime.gp seed "new") "${e.name}"
+        let nks ← keysof newmap
+        if nks.size > 0 then do
+          let payload ← SdkRuntime.gp newmap nks[0]!
+          let created ← ${ns}.create tclient payload (← emptyMap)
+          let cid ← SdkRuntime.gpS created "id"
+          if cid == "" then fail "${e.name}.create offline returned no id" else do
+            let m2 ← newMap #[("id", .str cid)]
+            let back ← ${ns}.load tclient m2 (← emptyMap)
+            if (← SdkRuntime.gpS back "id") == cid then
+              pass s!"${e.name}.create/load offline (id={cid})"
+            else fail s!"${e.name}.create/load offline mismatch"
+            let _ ← ${ns}.remove tclient m2 (← emptyMap)
+            let gone ← ${ns}.load tclient m2 (← emptyMap)
+            match gone with
+            | .map _ => fail s!"${e.name}.remove offline: still present"
+            | _ => pass s!"${e.name}.remove offline (id={cid})")
+`
+  })
+
+  // Per-entity LIVE test blocks.
+  let blocks = ''
+  each(entity, (e: any) => {
+    const ns = e.name.charAt(0).toUpperCase() + e.name.slice(1)
+    const listOp = (e.op || {}).list
+    const createOp = (e.op || {}).create
+    const removeOp = (e.op || {}).remove
+
+    if (hasParamFreePoint(listOp)) {
+      blocks += `    -- ${e.name}: list smoke
+    (do
+      let items ← ${ns}.list client (← emptyMap) (← emptyMap)
+      match items with
+      | .list lid => pass s!"${e.name}.list -> {(← listItems lid).size} items"
+      | _ => fail "${e.name}.list did not return a list")
+`
+    }
+
+    // Round-trip when create is param-free (creatable without an id); load and
+    // remove then use the id returned by create.
+    const loadOp = (e.op || {}).load
+    if (hasParamFreePoint(createOp) && loadOp && removeOp) {
+      const data = JSON.stringify(synthData(e.fields))
+      blocks += `    -- ${e.name}: create / load / remove round-trip
+    (do
+      let d ← SdkJson.jsonRead ${JSON.stringify(data)}
+      let created ← ${ns}.create client d (← emptyMap)
+      let nid ← SdkRuntime.gpS created "id"
+      if nid == "" then fail "${e.name}.create returned no id" else do
+        let m ← newMap #[("id", .str nid)]
+        let back ← ${ns}.load client m (← emptyMap)
+        let bid ← SdkRuntime.gpS back "id"
+        if bid == nid then pass s!"${e.name}.create/load round-trip (id={nid})"
+        else fail s!"${e.name}.load mismatch: {bid} != {nid}"
+        let _ ← ${ns}.remove client m (← emptyMap)
+        pass s!"${e.name}.remove (id={nid})")
+`
+    }
+  })
+
+  // The live lane nests two levels deeper than the offline lane.
+  const liveBlocks = blocks.split('\n').map((l) => l ? '  ' + l : l).join('\n')
+
+  Folder({ name: 'test' }, () => {
+  File({ name: 'Runner.' + target.ext }, () => {
+    Content(`-- ${model.const.Name} SDK test runner (generated by @voxgig/sdkgen).
+--
+-- OFFLINE lane (always): a test-mode client seeded from the generated entity
+-- test data answers operations from an in-memory store — no server needed.
+-- LIVE lane (only when SDK_TEST_BASE is set): the same flow over real HTTP.
+
+import VoxgigStruct
+import SdkJson
+import SdkRuntime
+import SdkClient
+
+open VoxgigStruct
+
+initialize npass : IO.Ref Nat ← IO.mkRef 0
+initialize nfail : IO.Ref Nat ← IO.mkRef 0
+
+def pass (msg : String) : SIO Unit := do
+  npass.modify (· + 1)
+  IO.println s!"ok   - {msg}"
+
+def fail (msg : String) : SIO Unit := do
+  nfail.modify (· + 1)
+  IO.println s!"FAIL - {msg}"
+
+def defaultBase : String := "http://localhost:8901"
+
+def main : IO UInt32 := do
+  let liveBase ← IO.getEnv "SDK_TEST_BASE"
+  let ctx ← mkCtx
+  let offline : SIO Unit := do
+${offline}  offline.run ctx
+  match liveBase with
+  | none => IO.println "skip - live lane (set SDK_TEST_BASE to enable)"
+  | some base => do
+    let live : SIO Unit := do
+      let opts ← newMap #[("base", .str base)]
+      let client ← Sdk.newSdk opts
+${liveBlocks}    live.run ctx
+  let p ← npass.get
+  let f ← nfail.get
+  IO.println ""
+  IO.println s!"PASS {p}  FAIL {f}"
+  if f > 0 then return 1 else return 0
+`)
+  })
+  })
+})
+
+
+export {
+  Test
+}

package/project/.sdk/src/cmp/lean/utility_lean.ts

@@ -0,0 +1,78 @@
+import * as Path from 'node:path'
+
+import {
+  clone,
+  walk,
+} from '@voxgig/struct'
+
+
+function projectPath(suffix?: string): string {
+  return Path.normalize(Path.join(__dirname, '../../..', suffix ?? ''))
+}
+
+
+// A Lean 4 string literal. Lean strings are UTF-8, so non-ASCII passes through;
+// only the structural characters need escaping. (Backticks are ordinary in Lean
+// strings, so the config's `body`-style transform exprs embed verbatim.)
+function leanString(s: string): string {
+  let out = '"'
+  for (const ch of String(s)) {
+    if (ch === '"') out += '\\"'
+    else if (ch === '\\') out += '\\\\'
+    else if (ch === '\n') out += '\\n'
+    else if (ch === '\t') out += '\\t'
+    else if (ch === '\r') out += '\\r'
+    else out += ch
+  }
+  return out + '"'
+}
+
+
+// Lean reserved words that cannot be bare identifiers.
+const LEAN_RESERVED = new Set<string>([
+  'do', 'let', 'fun', 'match', 'with', 'if', 'then', 'else', 'by', 'end',
+  'namespace', 'section', 'open', 'import', 'def', 'partial', 'mutual',
+  'structure', 'inductive', 'class', 'instance', 'where', 'deriving', 'return',
+  'try', 'catch', 'for', 'in', 'while', 'have', 'show', 'from', 'set_option',
+])
+
+
+// A collision-free lower-camel Lean identifier for a model name.
+function leanVarName(name: string): string {
+  let s = String(name).replace(/[^a-zA-Z0-9_]/g, '_')
+  if (s.length === 0) {
+    s = 'x'
+  }
+  s = s.charAt(0).toLowerCase() + s.slice(1)
+  if (!/^[a-z_]/.test(s)) {
+    s = 'e_' + s
+  }
+  return LEAN_RESERVED.has(s) ? s + '_' : s
+}
+
+
+// The lowercase-hyphenated package name (used for the lake package + repo).
+function pkgName(model: any): string {
+  const org = (model.origin || 'voxgig-sdk').replace(/-sdk$/, '')
+  return `${org}-${model.name}-sdk`.toLowerCase().replace(/[^a-z0-9-]/g, '-')
+}
+
+
+// Remove `$`-suffixed model annotation keys (so the embedded config is clean).
+function clean(o: any) {
+  return walk(clone(o), (k: any, v: any, p: any) => {
+    if (null != k && k.endsWith('$')) {
+      delete p[k]
+    }
+    return v
+  })
+}
+
+
+export {
+  clean,
+  leanString,
+  leanVarName,
+  pkgName,
+  projectPath,
+}

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

@@ -54,7 +54,7 @@ const Config = cmp(async function Config(props: any) {
 
   File({ name: 'config.' + target.ext }, () => {
 
-    Content(`-- ProjectName SDK configuration
+    Content(`-- ${model.const.Name} SDK configuration
 
 local function make_config()
   return {

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

@@ -21,7 +21,7 @@ import {
   File, Content,
 } from '@voxgig/sdkgen'
 
-import { canonToType, opTypeName, opRequestShape } from '@voxgig/sdkgen'
+import { canonToType, opTypeName, opRequestShape, warnEntityTypeCollisions , deriveEntityNames } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -41,14 +41,27 @@ function propKey(name: string): string {
 
 const EntityTypes = cmp(function EntityTypes(props: any) {
   const { target } = props
-  const { model } = props.ctx$
-
-  const entity = getModelPath(model, `main.${KIT}.entity`)
-  const entityList = each(entity).filter((e: any) => e.active !== false)
+  const { model, log } = props.ctx$
+
+  // only_active:false — getModelPath DROPS active:false entries by default,
+  // but the consumer scaffold (create-sdkgen Root.ts) iterates the RAW entity
+  // collection, so inactive entities still get generated entity code that
+  // references these typed names. The typed model must cover them too.
+  const entity = getModelPath(model, `main.${KIT}.entity`, { only_active: false, required: false })
+  // Emit for EVERY entity that gets generated entity code: the consumer
+  // scaffold (create-sdkgen Root.ts) iterates entities WITHOUT an active
+  // filter, so inactive entities still get class files referencing these
+  // typed names. Filter on `name` (always present), NOT `active` — parity
+  // with the go emitter's fix.
+  const entityList = deriveEntityNames(entity)
   // Derive the PascalCase Name up-front — it is set LAZILY by names(), so an
   // entity not yet named (e.g. a fieldless placeholder) would otherwise read
   // `Name = undefined` below. Parity with the go emitter's fix.
-  entityList.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
+
+  // Surface duplicate generated type names (two entities with the same
+  // PascalCase Name) — they would redeclare a type in statically-typed
+  // targets. Detection only; renaming is a model-level decision.
+  warnEntityTypeCollisions(entity, log, LANG)
 
   File({ name: model.name + '_types.' + (target.ext || LANG) }, () => {
 

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

@@ -4,7 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, camelify, names,
   File, Content, Folder, Fragment, Line, FeatureHook, Slot,
-  entityClassName,
+  entityClassName, entityCollection,
 } from '@voxgig/sdkgen'
 
 import {
@@ -24,7 +24,7 @@ const Entity = cmp(function Entity(props: any) {
   // data-type name. The class is a module-local table (snake-cased file name),
   // so this is used only for the local identifier — kept uniform with the other
   // languages.
-  const entityColl = getModelPath(model, `main.${KIT}.entity`)
+  const entityColl = entityCollection(model)
   const cls = entityClassName(entity, entityColl)
 
   const entrep = {
@@ -40,7 +40,7 @@ const Entity = cmp(function Entity(props: any) {
 
     File({ name: entity.name + '_entity.' + target.ext }, () => {
 
-      const opnames = Object.keys(entity.op)
+      const opnames = Object.keys(entity.op || {})
 
       const opfrags =
         (['load', 'list', 'create', 'update', 'remove']

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

@@ -55,7 +55,19 @@ const Main = cmp(async function Main(props: any) {
         replace: {
           ...props.ctx$.stdrep,
 
-          '#BuildFeatures': ({ indent }: any) => {
+          // Load the LuaLS typed-model annotations module so it is part of
+          // the loaded program (module body is empty — no runtime effect) and
+          // does not depend on workspace-wide language-server scanning.
+          // NOTE: plain marker keys must EMBED the lua comment prefix
+          // (`-- #X`) — jostraca's bare `#X` form only matches `//`-style
+          // comment lines (cf. the `'-- #LoadOp'` keys in Entity_lua.ts).
+          '-- #TypesRequire': ({ indent }: any) => Content({ indent },
+            `-- Typed-model annotations (LuaLS ---@class); empty at runtime.\n` +
+            `require("${model.name}_types")`),
+
+          // Same embedded `-- ` prefix requirement as above (the bare
+          // '#BuildFeatures' key never matched the lua comment line).
+          '-- #BuildFeatures': ({ indent }: any) => {
             each(feature, (feat: any) => {
               const fname = feat.name.charAt(0).toUpperCase() + feat.name.slice(1)
               Content({ indent }, `  -- feature: ${feat.name}
@@ -90,7 +102,7 @@ self._utility.feature_hook(self._rootctx, "${name}")
 
   // Generate feature factory module
   File({ name: 'features.' + target.ext }, () => {
-    Content(`-- ProjectName SDK feature factory
+    Content(`-- ${model.const.Name} SDK feature factory
 
 local BaseFeature = require("feature.base_feature")
 `)

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

@@ -57,7 +57,7 @@ dependencies = {
 `)
 
     const seen = new Set<string>(['lua', 'dkjson'])
-    for (const d of collectDeps(model, target.name, target.deps)) {
+    for (const d of collectDeps(model, target.name, target.deps, ctx$.log)) {
       if (seen.has(d.name)) continue
       seen.add(d.name)
       const v = d.source === 'target' ? (d.version || '0.0') : d.version

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, canonKey, entityIdField, opRequestShape, safeVarName } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, canonKey, entityIdField, opRequestShape, safeVarName, exampleVarName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -63,7 +63,7 @@ const ReadmeEntity = cmp(function ReadmeEntity(props: any) {
     const idF = entityIdField(entity)
     // Sanitise the local variable name — an entity whose lowercased name is a
     // Lua keyword (e.g. `end`) would otherwise emit uncompilable code.
-    const eVar = safeVarName(entity.name, 'lua')
+    const eVar = exampleVarName(entity.name, 'lua')
 
     Content(`
 ### ${entity.Name}

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

@@ -36,7 +36,12 @@ const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
   const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
   let testCallArg = ''
   if (exampleEntity && isMatchOp) {
-    testCallArg = idF ? `{ ${idF} = "test01" }` : ''
+    const items = opRequestShape(exampleEntity, primaryOp).items
+      .filter((it: any) => !it.optional || it.name === idF)
+      .sort((a: any, b: any) => (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
+    testCallArg = 0 < items.length
+      ? `{ ${items.map((it: any) => `${luaKey(it.name)} = ${it.name === idF ? '"test01"' : luaLit(it.type)}`).join(', ')} }`
+      : ''
   } else if (exampleEntity && ('create' === primaryOp || 'update' === primaryOp)) {
     const items = opRequestShape(exampleEntity, primaryOp).items
       .filter((it: any) => it.name !== idF && it.name !== 'id')

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, isAuthActive, envName, canonKey, opRequestShape, entityIdField, entityDataIdField, entityOps, safeVarName } from '@voxgig/sdkgen'
+import { cmp, each, Content, isAuthActive, envName, canonKey, opRequestShape, entityIdField, entityDataIdField, entityOps, safeVarName, exampleVarName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -45,7 +45,7 @@ local client = ${ctor}
     const article = /^[aeiou]/i.test(eName) ? "an" : "a"
     // Sanitise the local variable name — an entity whose lowercased name is a
     // Lua keyword (e.g. `end`) would otherwise emit uncompilable code.
-    const eVar = safeVarName(eName.toLowerCase(), 'lua')
+    const eVar = exampleVarName(eName.toLowerCase(), 'lua')
     const opnames = entityOps(exampleEntity)
     // Model-driven id key: `idF` is the MATCH key (null when none). `dataIdF`
     // is the id on the RETURNED record's data type — an entity can key its match
@@ -108,7 +108,7 @@ end
     if (nestedEntity) {
       const neName = nom(nestedEntity, 'Name')
       const neArticle = /^[aeiou]/i.test(neName) ? "an" : "a"
-      const neVar = safeVarName(neName.toLowerCase(), 'lua')
+      const neVar = exampleVarName(neName.toLowerCase(), 'lua')
 
       // Model-driven match: every REQUIRED load-match key — the same shape
       // the runtime resolves path params from, so the example always works.

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, canonKey, File, isAuthActive, entityIdField, opRequestShape, safeVarName } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, canonKey, File, isAuthActive, entityIdField, opRequestShape, safeVarName, exampleVarName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -176,7 +176,7 @@ same parameters as \`direct()\`.
       const idF = entityIdField(ent)
       // Sanitise the local variable name — an entity whose lowercased name is
       // a Lua keyword (e.g. `end`) would otherwise emit uncompilable code.
-      const eVar = safeVarName(ent.name, 'lua')
+      const eVar = exampleVarName(ent.name, 'lua')
 
       Content(`
 ---

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

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive, envName, canonKey, entityIdField, opRequestShape, safeVarName } from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, envName, canonKey, entityIdField, opRequestShape, safeVarName, exampleVarName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -48,7 +48,7 @@ local client = ${ctor}
     const eName = nom(exampleEntity, 'Name')
     // Sanitise the local variable name — an entity whose lowercased name is a
     // Lua keyword (e.g. `end`) would otherwise emit uncompilable code.
-    const eVar = safeVarName(eName.toLowerCase(), 'lua')
+    const eVar = exampleVarName(eName.toLowerCase(), 'lua')
     const opnames = Object.keys(exampleEntity.op || {})
     // Model-driven id key: null when the entity has no id-like field, in which
     // case the load example takes no match argument.

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

@@ -70,7 +70,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
     ? `\n      apikey = env["${PROJECTNAME}_APIKEY"],`
     : ''
 
-  const opnames = Object.keys(entity.op)
+  const opnames = Object.keys(entity.op || {})
   const hasLoad = opnames.includes('load')
   const hasList = opnames.includes('list')
 
@@ -78,8 +78,8 @@ const TestDirect = cmp(function TestDirect(props: any) {
     return
   }
 
-  const loadOp = entity.op.load
-  const listOp = entity.op.list
+  const loadOp = entity.op?.load
+  const listOp = entity.op?.list
 
   const loadPoint = loadOp?.points?.[0]
   const loadPath = loadPoint ? normalizePathParams(loadPoint.parts || [], loadPoint?.args?.params || [], loadPoint?.rename?.param) : ''

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

@@ -24,6 +24,7 @@ import {
   buildIdNames,
   getMatchEntries,
   isAuthActive,
+  entityDataIdField,
 } from '@voxgig/sdkgen'
 
 
@@ -49,7 +50,7 @@ const TestEntity = cmp(function TestEntity(props: any) {
   // it only applies to entities that declare a list op. Others (e.g. Batch =
   // create/load) have no list endpoint — make_point errors and the stream
   // yields nothing — so skip the stream test for them.
-  const hasList = !!(entity.op && (entity.op as any).list)
+  const hasList = !!(entity.op && (entity.op as any)?.list)
 
   const basicflow: ModelEntityFlow | undefined =
     getModelPath(model, `main.${KIT}.flow.Basic${nom(entity, 'Name')}Flow`)
@@ -342,6 +343,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
 
 const generateList: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
+  const hasDataId = null != entityDataIdField(entity)
   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 ?? ''))
@@ -387,7 +389,7 @@ const generateList: OpGen = (ctx, step, index) => {
       const hasRefData = validRef && allSteps.some((s: any) => 'create' === s.op &&
         ((s.input.ref ?? entity.name + '_ref01') === validRef))
 
-      if ('ItemExists' === validator.apply && hasRefData) {
+      if ('ItemExists' === validator.apply && hasRefData && hasDataId) {
         const refDataVar = validRef + '_data'
         Content(`
     local found_item = vs.select(
@@ -395,7 +397,7 @@ const generateList: OpGen = (ctx, step, index) => {
       { id = ${refDataVar}["id"] })
     assert.is_false(vs.isempty(found_item))
 `)
-      } else if ('ItemNotExists' === validator.apply && hasRefData) {
+      } else if ('ItemNotExists' === validator.apply && hasRefData && hasDataId) {
         const refDataVar = validRef + '_data'
         Content(`
     local not_found_item = vs.select(
@@ -548,6 +550,9 @@ const generateLoad: OpGen = (ctx, step, index) => {
 
 const generateRemove: OpGen = (ctx, step, index) => {
   const { entity, flow } = ctx
+  if (null == entityDataIdField(entity)) {
+    return
+  }
   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 ?? ''))

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

@@ -24,7 +24,7 @@ const Test = cmp(function Test(props: any) {
 
     // Generate exists test
     File({ name: 'exists_test.' + target.ext }, () => {
-      Content(`-- ProjectName SDK exists test
+      Content(`-- ${model.const.Name} SDK exists test
 
 local sdk = require("${model.name}_sdk")
 

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

@@ -8,6 +8,8 @@ local helpers = require("core.helpers")
 -- Load utility registration (populates Utility._registrar)
 require("utility.register")
 
+-- #TypesRequire
+
 -- Load features
 local BaseFeature = require("feature.base_feature")
 local features_factory = require("features")