@voxgig/sdkgen 1.2.0 → 1.3.1

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

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, File, isAuthActive } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, File, isAuthActive, entityIdField } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -70,8 +70,7 @@ Create a new SDK client instance.
 | Name | Type | Description |
 | --- | --- | --- |
 | \`options\` | \`map[string]any\` | SDK configuration options. |
-| \`options["apikey"]\` | \`string\` | API key for authentication. |
-| \`options["base"]\` | \`string\` | Base URL for API requests. |
+${isAuthActive(model) ? '| \`options["apikey"]\` | \`string\` | API key for authentication. |\n' : ''}| \`options["base"]\` | \`string\` | Base URL for API requests. |
 | \`options["prefix"]\` | \`string\` | URL prefix appended after base. |
 | \`options["suffix"]\` | \`string\` | URL suffix appended after path. |
 | \`options["headers"]\` | \`map[string]any\` | Custom headers for all requests. |
@@ -86,12 +85,20 @@ Create a new SDK client instance.
 
 `)
 
-    Content(`#### \`TestSDK(testopts, sdkopts map[string]any) *${model.const.Name}SDK\`
+    Content(`#### \`Test() *${model.const.Name}SDK\`
 
-Create a test client with mock features active. Both arguments may be \`nil\`.
+No-arg convenience constructor for the common no-options test case.
 
 \`\`\`go
-client := sdk.TestSDK(nil, nil)
+client := sdk.Test()
+\`\`\`
+
+#### \`TestSDK(testopts, sdkopts map[string]any) *${model.const.Name}SDK\`
+
+Test client with options. Both arguments may be \`nil\`.
+
+\`\`\`go
+client := sdk.TestSDK(testopts, sdkopts)
 \`\`\`
 
 `)
@@ -153,6 +160,9 @@ same parameters as \`Direct()\`.
     publishedEntities.map((ent: any) => {
       const opnames = Object.keys(ent.op || {})
       const fields = ent.fields || []
+      // Model-driven id key: null when this entity has no id-like field, in
+      // which case load/remove pass a nil match and update omits the id.
+      const idF = entityIdField(ent)
 
       Content(`
 ---
@@ -184,7 +194,7 @@ ${ent.name} := client.${ent.Name}(nil)
         each(fields, (field: any) => {
           const req = field.req ? 'Yes' : 'No'
           const desc = field.short || ''
-          Content(`| \`${field.name}\` | \`${field.type || 'any'}\` | ${req} | ${desc} |
+          Content(`| \`${field.name}\` | \`${canonToType(field.type, target.name)}\` | ${req} | ${desc} |
 `)
         })
 
@@ -194,15 +204,18 @@ ${ent.name} := client.${ent.Name}(nil)
         // Field operations breakdown
         const hasFieldOps = fields.some((f: any) => f.op && Object.keys(f.op).length > 0)
         if (hasFieldOps) {
+          // Only emit columns for operations this entity actually exposes —
+          // never advertise a create/update/remove column the entity lacks.
+          const opcols = ['load', 'list', 'create', 'update', 'remove']
+            .filter((op: string) => opnames.includes(op) && ent.op[op]?.active !== false)
           Content(`### Field Usage by Operation
 
-| Field | load | list | create | update | remove |
-| --- | --- | --- | --- | --- | --- |
+| Field | ${opcols.join(' | ')} |
+| --- | ${opcols.map(() => '---').join(' | ')} |
 `)
           each(fields, (field: any) => {
             const fops = field.op || {}
-            const cols = ['load', 'list', 'create', 'update', 'remove'].map((op: string) => {
-              if (!opnames.includes(op)) return '-'
+            const cols = opcols.map((op: string) => {
               const fop = fops[op]
               if (null == fop) return '-'
               if (fop.active === false) return '-'
@@ -238,7 +251,7 @@ ${info.desc}
           if ('load' === opname || 'remove' === opname) {
             const goOpName = opname.charAt(0).toUpperCase() + opname.slice(1)
             Content(`\`\`\`go
-result, err := client.${ent.Name}(nil).${goOpName}(map[string]any{"id": "${ent.name}_id"}, nil)
+result, err := client.${ent.Name}(nil).${goOpName}(${idF ? `map[string]any{"${idF}": "${ent.name}_id"}` : 'nil'}, nil)
 \`\`\`
 
 `)
@@ -256,7 +269,7 @@ result, err := client.${ent.Name}(nil).Create(map[string]any{
 `)
             each(fields, (field: any) => {
               if ('id' !== field.name && field.req) {
-                Content(`    "${field.name}": /* ${field.type || 'value'} */,
+                Content(`    "${field.name}": /* ${canonToType(field.type, target.name)} */,
 `)
               }
             })
@@ -266,10 +279,10 @@ result, err := client.${ent.Name}(nil).Create(map[string]any{
 `)
           }
           else if ('update' === opname) {
+            const updateIdLine = idF ? `    "${idF}": "${ent.name}_id",\n` : ''
             Content(`\`\`\`go
 result, err := client.${ent.Name}(nil).Update(map[string]any{
-    "id": "${ent.name}_id",
-    // Fields to update
+${updateIdLine}    // Fields to update
 }, nil)
 \`\`\`
 

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

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive } from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, envName, entityIdField, safeVarName } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -13,29 +13,35 @@ const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
   // Go module path == repo path on GitHub (org from model.origin).
-  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk`
+  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk/go`
 
   const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
-  const apikeyArg = isAuthActive(model)
-    ? `\n    "apikey": os.Getenv("${model.NAME}_APIKEY"),\n`
-    : ''
+  const authActive = isAuthActive(model)
+  const ctor = authActive
+    ? `sdk.New${model.const.Name}SDK(map[string]any{\n    "apikey": os.Getenv("${envName(model)}_APIKEY"),\n})`
+    : `sdk.New()`
 
   Content(`\`\`\`go
 import sdk "${gomodule}"
 
-client := sdk.New${model.const.Name}SDK(map[string]any{${apikeyArg}})
+client := ${ctor}
 
 `)
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
+    const eVar = safeVarName(eName.toLowerCase(), 'go')
     const opnames = Object.keys(exampleEntity.op || {})
 
+    let hasCall = false
+
     if (opnames.includes('list')) {
       Content(`// List all ${eName.toLowerCase()}s
-${eName.toLowerCase()}s, err := client.${eName}(nil).List(nil, nil)
+${eVar}s, err := client.${eName}(nil).List(nil, nil)
+fmt.Println(${eVar}s)
 `)
+      hasCall = true
     }
 
     // Find a nested entity for a more interesting example
@@ -45,16 +51,34 @@ ${eName.toLowerCase()}s, err := client.${eName}(nil).List(nil, nil)
 
     if (nestedEntity && opnames.includes('load')) {
       const neName = nom(nestedEntity, 'Name')
+      const neVar = safeVarName(neName.toLowerCase(), 'go')
       const parentFields = (nestedEntity.fields || [])
         .filter((f: any) => f.name !== 'id' && f.name.endsWith('_id'))
       const parentParam = parentFields.length > 0 ? parentFields[0].name : 'parent_id'
+      // Model-driven id key: only include the nested entity's id if it has one.
+      const neIdF = entityIdField(nestedEntity)
+      const neMatchPairs = [`"${parentParam}": "example"`]
+      if (neIdF) {
+        neMatchPairs.push(`"${neIdF}": "example_id"`)
+      }
 
       Content(`
 // Load a specific ${neName.toLowerCase()}
-${neName.toLowerCase()}, err := client.${neName}(nil).Load(
-    map[string]any{"${parentParam}": "example", "id": "example_id"}, nil,
+${neVar}, err := client.${neName}(nil).Load(
+    map[string]any{${neMatchPairs.join(', ')}}, nil,
 )
+fmt.Println(${neVar})
+`)
+      hasCall = true
+    }
+
+    // Fallback: APIs with only `load` (no list, no nested) — still show one call.
+    if (!hasCall && opnames.includes('load')) {
+      Content(`// Load ${eName.toLowerCase()} data
+${eVar}, err := client.${eName}(nil).Load(map[string]any{}, nil)
+fmt.Println(${eVar})
 `)
+      hasCall = true
     }
   }
 

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

@@ -1,5 +1,5 @@
 
-import { cmp, Content } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, entityIdField, entityPrimaryOp, opRequestShape } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -8,23 +8,53 @@ import {
 } from '@voxgig/apidef'
 
 
+// A type-correct Go literal for a field's canonical type.
+function goLit(type: any): string {
+  const k = canonKey(type)
+  if ('INTEGER' === k || 'NUMBER' === k) return '1'
+  if ('BOOLEAN' === k) return 'true'
+  if ('ARRAY' === k) return '[]any{}'
+  if ('OBJECT' === k) return 'map[string]any{}'
+  return '"example"'
+}
+
+function cap(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+
 const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   const { target, ctx$: { model } } = props
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
   // Go module path == repo path on GitHub (org from model.origin).
-  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk`
+  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk/go`
 
   const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
   Content(`\`\`\`go
-client := sdk.TestSDK(nil, nil)
+client := sdk.Test()
 `)
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
-    Content(`result, err := client.${eName}(nil).Load(
-    map[string]any{"id": "test01"}, nil,
+    // Drive the test-mode example off the entity's PRIMARY op (never a hardcoded
+    // `Load` a create-only entity lacks).
+    const idF = entityIdField(exampleEntity)
+    const primaryOp = entityPrimaryOp(exampleEntity) || 'load'
+    const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
+    let arg = 'nil'
+    if (isMatchOp) {
+      arg = idF ? `map[string]any{"${idF}": "test01"}` : 'nil'
+    } else if ('create' === primaryOp || 'update' === primaryOp) {
+      const items = opRequestShape(exampleEntity, primaryOp).items
+        .filter((it: any) => it.name !== idF && it.name !== 'id')
+      const required = items.filter((it: any) => !it.optional)
+      const chosen = required.length ? required : items.slice(0, 3)
+      arg = `map[string]any{${chosen.map((it: any) => `"${it.name}": ${goLit(it.type)}`).join(', ')}}`
+    }
+    Content(`result, err := client.${eName}(nil).${cap(primaryOp)}(
+    ${arg}, nil,
 )
 `)
   }

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

@@ -107,7 +107,7 @@ import (
 	sdk "${gomodule}"
 	"${gomodule}/core"
 
-	vs "github.com/voxgig/struct"
+	vs "${gomodule}/utility/struct"
 )
 
 func Test${entity.Name}Entity(t *testing.T) {

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

@@ -13,6 +13,7 @@ import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
 
 import { TestEntity } from './TestEntity_go'
 import { TestDirect } from './TestDirect_go'
+import { ReadmeExamplesTest } from './ReadmeExamplesTest_go'
 
 
 const Test = cmp(function Test(props: any) {
@@ -21,7 +22,7 @@ const Test = cmp(function Test(props: any) {
 
   // Module name: concatenated lowercase
   // Go module path == repo path on GitHub (org from model.origin).
-  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk`
+  const gomodule = `github.com/${model.origin || 'voxgig-sdk'}/${model.name}-sdk/go`
 
   Folder({ name: 'test' }, () => {
 
@@ -51,6 +52,9 @@ func TestExists(t *testing.T) {
       TestEntity({ target, entity, gomodule })
       TestDirect({ target, entity, gomodule })
     })
+
+    // README ```go example snippets must compile against the real SDK.
+    ReadmeExamplesTest({ target })
   })
 })
 

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

@@ -85,6 +85,27 @@ func (e *EntityNameEntity) Match(args ...any) any {
 	return out
 }
 
+// DataTyped is the statically-typed accessor for this entity's data. With no
+// argument it returns the current data as an EntityName; with an argument it
+// sets the data and returns the stored value. It delegates to the untyped Data
+// (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) DataTyped(data ...EntityName) EntityName {
+	if len(data) > 0 {
+		return typedFrom[EntityName](e.Data(asMap(data[0])))
+	}
+	return typedFrom[EntityName](e.Data())
+}
+
+// MatchTyped mirrors DataTyped for the entity's match filter. The match is a
+// partial of the entity, so it round-trips through EntityName (all fields
+// optional at the wire level).
+func (e *EntityNameEntity) MatchTyped(match ...EntityName) EntityName {
+	if len(match) > 0 {
+		return typedFrom[EntityName](e.Match(asMap(match[0])))
+	}
+	return typedFrom[EntityName](e.Match())
+}
+
 // #LoadOp
 
 // #ListOp

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

@@ -32,4 +32,15 @@ func (e *EntityNameEntity) Create(reqdata map[string]any, ctrl map[string]any) (
 	})
 }
 
+// CreateTyped is the statically-typed variant of Create: it takes an
+// EntityNameCreateData and returns an EntityName. It delegates to the untyped
+// Create (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) CreateTyped(reqdata EntityNameCreateData, ctrl map[string]any) (EntityName, error) {
+	res, err := e.Create(asMap(reqdata), ctrl)
+	if err != nil {
+		return EntityName{}, err
+	}
+	return typedFrom[EntityName](res), nil
+}
+
 // EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityListOp.fragment.go

@@ -23,4 +23,15 @@ func (e *EntityNameEntity) List(reqmatch map[string]any, ctrl map[string]any) (a
 	})
 }
 
+// ListTyped is the statically-typed variant of List: it takes an
+// EntityNameListMatch and returns []EntityName. It delegates to the untyped
+// List (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) ListTyped(reqmatch EntityNameListMatch, ctrl map[string]any) ([]EntityName, error) {
+	res, err := e.List(asMap(reqmatch), ctrl)
+	if err != nil {
+		return nil, err
+	}
+	return typedSliceFrom[EntityName](res), nil
+}
+
 // EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityLoadOp.fragment.go

@@ -35,4 +35,15 @@ func (e *EntityNameEntity) Load(reqmatch map[string]any, ctrl map[string]any) (a
 	})
 }
 
+// LoadTyped is the statically-typed variant of Load: it takes an
+// EntityNameLoadMatch and returns an EntityName. It delegates to the untyped
+// Load (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) LoadTyped(reqmatch EntityNameLoadMatch, ctrl map[string]any) (EntityName, error) {
+	res, err := e.Load(asMap(reqmatch), ctrl)
+	if err != nil {
+		return EntityName{}, err
+	}
+	return typedFrom[EntityName](res), nil
+}
+
 // EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityRemoveOp.fragment.go

@@ -35,4 +35,15 @@ func (e *EntityNameEntity) Remove(reqmatch map[string]any, ctrl map[string]any)
 	})
 }
 
+// RemoveTyped is the statically-typed variant of Remove: it takes an
+// EntityNameRemoveMatch and returns an EntityName. It delegates to the untyped
+// Remove (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) RemoveTyped(reqmatch EntityNameRemoveMatch, ctrl map[string]any) (EntityName, error) {
+	res, err := e.Remove(asMap(reqmatch), ctrl)
+	if err != nil {
+		return EntityName{}, err
+	}
+	return typedFrom[EntityName](res), nil
+}
+
 // EJECT-END

package/project/.sdk/src/cmp/go/fragment/EntityUpdateOp.fragment.go

@@ -35,4 +35,15 @@ func (e *EntityNameEntity) Update(reqdata map[string]any, ctrl map[string]any) (
 	})
 }
 
+// UpdateTyped is the statically-typed variant of Update: it takes an
+// EntityNameUpdateData and returns an EntityName. It delegates to the untyped
+// Update (identical runtime) and converts at the typed boundary.
+func (e *EntityNameEntity) UpdateTyped(reqdata EntityNameUpdateData, ctrl map[string]any) (EntityName, error) {
+	res, err := e.Update(asMap(reqdata), ctrl)
+	if err != nil {
+		return EntityName{}, err
+	}
+	return typedFrom[EntityName](res), nil
+}
+
 // EJECT-END

package/project/.sdk/src/cmp/go-cli/Main_go-cli.ts

@@ -0,0 +1,195 @@
+
+import * as Path from 'node:path'
+
+import {
+  cmp, each,
+  File, Content, Fragment, Slot,
+} from '@voxgig/sdkgen'
+
+import type {
+  ModelEntity,
+} from '@voxgig/apidef'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+// Published aql/eng/go version. Tagged at aql-lang/aql under
+// eng/go/v<X.Y.Z>. Bump here when adopting a newer engine.
+const AQL_ENG_VERSION = 'v0.0.1'
+
+
+const Main = cmp(function Main(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+  const org = model.origin || 'voxgig-sdk'
+  const sdkModule = `github.com/${org}/${model.name}-sdk/go`
+  const cliModule = `github.com/${org}/${model.name}-sdk/go-cli`
+
+  const entityMap: any = getModelPath(model, `main.${KIT}.entity`)
+  const entityNames = Object.keys(entityMap).map(n => n.toLowerCase())
+
+  const FRAGMENT = Path.normalize(__dirname + '/../../../src/cmp/go-cli/fragment')
+
+  // .gitignore — the compiled binary lands at /<modulename>-cli; ignore it.
+  File({ name: '.gitignore' }, () => Content(`/${model.name}-cli
+`))
+
+  // README.md — usage guide for the AQL-driven CLI.
+  const entityList = entityNames.length > 0 ? entityNames.join(' ') : '(none)'
+
+  // MODEL-DRIVEN verbs. The CLI implements three AQL words (list / load /
+  // update; see words.fragment.go + runOp). Each README verb row is
+  // advertised ONLY when at least one active entity actually exposes that
+  // op (op.<name>.active !== false) — never document an operation no entity
+  // supports.
+  const CLI_VERB_ROWS: Record<string, string> = {
+    list:   '| `list`   | `[entity]` · `[query entity]`                | List records               |',
+    load:   '| `load`   | `[entity]` · `[query entity]`                | Load a single record       |',
+    update: '| `update` | `[entity]` · `[query entity]`                | Update a record            |',
+  }
+  const supportedOps = new Set<string>()
+  each(entityMap, (entity: any) => {
+    if (entity && entity.active === false) return
+    const ops = (entity && entity.op) || {}
+    for (const opname of Object.keys(ops)) {
+      if (ops[opname] && ops[opname].active !== false) supportedOps.add(opname)
+    }
+  })
+  const verbRows = ['list', 'load', 'update']
+    .filter(op => supportedOps.has(op))
+    .map(op => CLI_VERB_ROWS[op])
+    .join('\n')
+
+  // MODEL-DRIVEN run examples, gated on the first entity's own ops so the
+  // Run section never demonstrates a verb the example entity lacks.
+  const firstEntityObj: any =
+    Object.values(entityMap).find((e: any) => e && e.active !== false)
+  const firstEntity = firstEntityObj
+    ? String(firstEntityObj.name).toLowerCase()
+    : (entityNames[0] || 'entity')
+  const firstOps: any = (firstEntityObj && firstEntityObj.op) || {}
+  const firstHas = (op: string) => !!(firstOps[op] && firstOps[op].active !== false)
+  const runLines: string[] = ['# One-shot: arguments form a single AQL expression']
+  if (firstHas('list')) {
+    runLines.push(`./${model.name}-cli list ${firstEntity}`)
+  }
+  if (firstHas('load')) {
+    runLines.push(`./${model.name}-cli load 1 ${firstEntity}`)
+    runLines.push(`./${model.name}-cli load '{id:1}' ${firstEntity}`)
+  }
+  if (firstHas('update')) {
+    runLines.push(`./${model.name}-cli update '{id:1}' ${firstEntity}`)
+  }
+
+  File({ name: 'README.md' }, () => Content(`# ${model.name}-cli
+
+AQL-driven CLI and REPL for the ${model.Name} SDK. Positional arguments are
+joined into a single AQL expression and evaluated; with no arguments,
+falls into an interactive REPL.
+
+Built on \`github.com/aql-lang/aql/eng/go\` and the sibling Go SDK at \`../go\`.
+
+## Build
+
+\`\`\`sh
+go build -o ${model.name}-cli ./...
+\`\`\`
+
+## Run
+
+\`\`\`sh
+${runLines.join('\n')}
+
+# REPL
+./${model.name}-cli
+\`\`\`
+
+## Words
+
+| Word     | Signatures                                   | Description                |
+|----------|----------------------------------------------|----------------------------|
+${verbRows}
+
+\`query\` is either a Map (\`{id:1}\`) or a Scalar (\`1\`, treated as \`{id:1}\`).
+\`entity\` is one of the SDK's entity names (auto-quoted as an atom).
+
+## Entities
+
+${entityList}
+
+## REPL commands
+
+- \`:quit\` / \`:q\` / \`:exit\` — exit the REPL
+- \`:help\` / \`:h\` / \`:?\`     — show help
+
+## Generated by
+
+sdkgen \`go-cli\` target. See the target source under
+\`.sdk/src/cmp/go-cli/\` in this repo, or upstream at
+\`github.com/voxgig/sdkgen/project/.sdk/src/cmp/go-cli/\`.
+`))
+
+  // go.mod — sibling SDK via relative replace; aql/eng/go from the
+  // public Go module proxy.
+  File({ name: 'go.mod' }, () => Content(`module ${cliModule}
+
+go 1.21
+
+require ${sdkModule} v0.0.0
+require github.com/aql-lang/aql/eng/go ${AQL_ENG_VERSION}
+
+replace ${sdkModule} => ../go
+`))
+
+  // main.go — produced from fragment/main.fragment.go with two Slots
+  // for the prompt label and the entity help line.
+  File({ name: 'main.go' }, () => {
+    Fragment(
+      {
+        from: Path.join(FRAGMENT, 'main.fragment.go'),
+        replace: {
+          ...props.ctx$.stdrep,
+          GOMODULE: sdkModule,
+        },
+      },
+      () => {
+        Slot({ name: 'promptName' }, () => Content(model.name))
+        Slot({ name: 'entityNamesSpaced' }, () => Content(entityNames.join(' ')))
+      },
+    )
+  })
+
+  // words.go — produced from fragment/words.fragment.go with a single
+  // Slot that emits one `case "<name>":` per entity.
+  File({ name: 'words.go' }, () => {
+    Fragment(
+      {
+        from: Path.join(FRAGMENT, 'words.fragment.go'),
+        replace: {
+          ...props.ctx$.stdrep,
+          GOMODULE: sdkModule,
+        },
+      },
+      () => {
+        Slot({ name: 'entityCases' }, () => {
+          each(entityMap, (entity: ModelEntity) => {
+            const lower = entity.name.toLowerCase()
+            const pascal = (entity as any).Name
+            Content(`\tcase "${lower}":
+\t\treturn client.${pascal}(nil), nil
+`)
+          })
+        })
+      },
+    )
+  })
+})
+
+
+export {
+  Main
+}