@voxgig/sdkgen 1.3.14 → 1.3.17

package/project/.sdk/src/cmp/elixir/ReadmeHowto_elixir.ts

@@ -0,0 +1,149 @@
+
+import { cmp, Content, isAuthActive, envName, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+import { elixirLit } from './utility_elixir'
+
+
+const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const Name = model.const.Name
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+
+  // Pick an entity with a real op (prefer a read op). primaryOp is null only
+  // when NO entity exposes any op (a direct()-only SDK).
+  const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
+  const eName = exampleEntity ? nom(exampleEntity, 'Name') : 'Entity'
+  const eVar = exampleEntity ? exampleEntity.name : 'entity'
+  const idF = exampleEntity ? entityIdField(exampleEntity) : null
+  const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
+  let testArg = 'H.deep(%{})'
+  if (exampleEntity && isMatchOp) {
+    testArg = idF ? `H.deep(%{"${idF}" => "test01"})` : 'H.deep(%{})'
+  } else if (exampleEntity && ('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)
+    testArg = `H.deep(%{${chosen.map((it: any) => `"${it.name}" => ${elixirLit(it.type)}`).join(', ')}})`
+  }
+
+  const resVar = 'list' === primaryOp ? 'records' : 'record'
+  const testModeExample = primaryOp
+    ? `# Entity ops return the bare record (raise on error).
+${eVar} = ${Name}.${eVar}(sdk)
+${resVar} = ${Name}.Entity.${eName}.${primaryOp}(${eVar}, ${testArg})
+IO.inspect(${resVar})`
+    : `result = ${Name}.direct(sdk, H.deep(%{"path" => "/api/resource", "method" => "GET"}))
+IO.inspect(result)`
+
+  const apikeyEnvLine = isAuthActive(model)
+    ? `\n${envName(model)}_APIKEY=<your-key>`
+    : ''
+
+  Content(`### Make a direct HTTP request
+
+For endpoints not covered by entity operations. \`direct/2\` never raises —
+it returns a result node you branch on with \`Voxgig.Struct.getprop/2\`:
+
+\`\`\`elixir
+alias Voxgig.Struct, as: S
+alias ${Name}.Helpers, as: H
+
+result = ${Name}.direct(sdk, H.deep(%{
+  "path" => "/api/resource/{id}",
+  "method" => "GET",
+  "params" => %{"id" => "example"}
+}))
+
+if S.getprop(result, "ok") do
+  IO.inspect(S.getprop(result, "status"))  # 200
+  IO.inspect(S.getprop(result, "data"))    # response body
+else
+  # A non-2xx response carries status + data (the error body); a
+  # transport-level failure carries err instead.
+  IO.inspect(S.getprop(result, "err"))
+end
+\`\`\`
+
+### Prepare a request without sending it
+
+\`\`\`elixir
+alias ${Name}.Helpers, as: H
+
+# prepare/2 returns the fetch definition and raises on error.
+fetchdef = ${Name}.prepare(sdk, H.deep(%{
+  "path" => "/api/resource/{id}",
+  "method" => "DELETE",
+  "params" => %{"id" => "example"}
+}))
+
+IO.inspect(Voxgig.Struct.getprop(fetchdef, "url"))
+IO.inspect(Voxgig.Struct.getprop(fetchdef, "method"))
+\`\`\`
+
+### Use test mode
+
+Create a mock client for unit testing — no server required:
+
+\`\`\`elixir
+alias ${Name}.Helpers, as: H
+
+sdk = ${Name}.test()
+
+${testModeExample}
+\`\`\`
+
+### Use a custom fetch function
+
+Replace the HTTP transport with your own function. It receives \`(url,
+fetchdef)\` and returns a \`{response, error}\` tuple:
+
+\`\`\`elixir
+alias Voxgig.Struct, as: S
+alias ${Name}.Helpers, as: H
+
+mock_fetch = fn _url, _fetchdef ->
+  response = H.deep(%{
+    "status" => 200,
+    "statusText" => "OK",
+    "headers" => %{},
+    "json" => fn -> %{"id" => "mock01"} end
+  })
+  {response, nil}
+end
+
+sdk = ${Name}.new(H.deep(%{
+  "base" => "http://localhost:8080",
+  "system" => %{"fetch" => mock_fetch}
+}))
+\`\`\`
+
+### Run live tests
+
+Create a \`.env.local\` file at the project root:
+
+\`\`\`
+${envName(model)}_TEST_LIVE=TRUE${apikeyEnvLine}
+\`\`\`
+
+Then run:
+
+\`\`\`bash
+cd ${target.name} && mix test
+\`\`\`
+
+`)
+
+})
+
+
+export {
+  ReadmeHowto
+}

package/project/.sdk/src/cmp/elixir/ReadmeInstall_elixir.ts

@@ -0,0 +1,67 @@
+
+import { cmp, Content, isPublished, repoInfo } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target, ctx$ } = props
+  const { model } = ctx$
+
+  // Match the app atom in mix.exs: snake_case, since `:a-b` is not a valid atom.
+  const app = model.const.name.toLowerCase().replace(/-/g, '_')
+
+  if (isPublished(model, target.name)) {
+    // Live on Hex: add the dependency to mix.exs deps/0.
+    Content(`Add \`${app}\` to your \`mix.exs\` dependencies:
+
+\`\`\`elixir
+def deps do
+  [
+    {:${app}, "~> 0.0.1"}
+  ]
+end
+\`\`\`
+
+Then fetch it:
+
+\`\`\`bash
+mix deps.get
+\`\`\`
+
+`)
+    return
+  }
+
+  // Publish pending: not yet on Hex. Install from the git release tag or a
+  // local path checkout.
+  const { repoUrl, releasesUrl } = repoInfo(model)
+  Content(`This package is not yet published to [Hex](https://hex.pm). Install it from
+the GitHub release tag (\`${target.name}/vX.Y.Z\`, see [Releases](${releasesUrl}))
+by adding a git dependency to your \`mix.exs\`:
+
+\`\`\`elixir
+def deps do
+  [
+    {:${app}, git: "${repoUrl}.git", tag: "${target.name}/vX.Y.Z"}
+  ]
+end
+\`\`\`
+
+Or from a local source checkout:
+
+\`\`\`elixir
+def deps do
+  [
+    {:${app}, path: "../${model.const.name.toLowerCase()}-sdk/${target.name}"}
+  ]
+end
+\`\`\`
+
+Then run \`mix deps.get\`.
+
+`)
+})
+
+
+export {
+  ReadmeInstall
+}

package/project/.sdk/src/cmp/elixir/ReadmeIntro_elixir.ts

@@ -0,0 +1,66 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+const ReadmeIntro = cmp(function ReadmeIntro(props: any) {
+  const { target, ctx$: { model } } = props
+  const info = (model.main && model.main.kit && model.main.kit.info) || {}
+  const tagline = info.tagline || ''
+
+  Content(`# ${model.Name} ${target.title} SDK
+
+${tagline}
+
+The ${target.title} SDK for the ${model.Name} API — an entity-oriented client
+following idiomatic, functional Elixir conventions.
+
+`)
+
+  // Emphasise the entity-oriented design: the SDK surfaces the API as
+  // capitalised, semantic Entities with a small, uniform verb set rather
+  // than raw URL paths and query strings. The example entity name is
+  // derived from the model, never hardcoded.
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const exampleEntity = Object.values(entity || {})
+    .find((e: any) => e.active !== false) as any
+  const example = exampleEntity
+    ? `for example \`${model.const.Name}.${exampleEntity.name}(sdk)\` — each`
+    : 'each'
+
+  // Model-driven op list — only the operations the active entities actually
+  // expose (a read-only entity has just list+load); never claim
+  // create/update/remove exist when no entity has them.
+  const CANON_OPS = ['list', 'load', 'create', 'update', 'remove']
+  const opSet = new Set<string>()
+  Object.values(entity || {}).forEach((e: any) => {
+    if (!e || e.active === false) return
+    Object.keys(e.op || {}).forEach((o: string) => {
+      if (e.op[o] && e.op[o].active !== false) opSet.add(o)
+    })
+  })
+  const opNames = CANON_OPS.filter((o) => opSet.has(o))
+    .concat([...opSet].filter((o) => !CANON_OPS.includes(o)))
+  const opList = (opNames.length ? opNames : ['list', 'load'])
+    .map((o) => '`' + o + '`').join(', ')
+
+  Content(`The SDK exposes the API as capitalised, semantic **Entities** — ${example}
+carrying a small, uniform set of operations (${opList}) instead of raw URL
+paths and query strings. You work with named resources and verbs, which
+keeps the cognitive load low.
+
+> Other languages, the CLI, and MCP server live alongside this one — see
+> the [top-level README](../README.md).
+
+`)
+})
+
+
+export {
+  ReadmeIntro
+}

package/project/.sdk/src/cmp/elixir/ReadmeModel_elixir.ts

@@ -0,0 +1,150 @@
+
+import { cmp, each, Content, isAuthActive } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+const ReadmeModel = cmp(function ReadmeModel(props: any) {
+  const { ctx$: { model } } = props
+
+  const Name = model.const.Name
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const entityList = each(entity).filter((e: any) => e.active !== false)
+
+  // Model-driven op rows for the shared entity interface: emit a
+  // load/list/create/update/remove row only for operations at least one active
+  // entity actually exposes.
+  const opUnion = new Set<string>()
+  entityList.forEach((e: any) => Object.keys(e.op || {})
+    .forEach((o: string) => { if (e.op[o] && e.op[o].active !== false) opUnion.add(o) }))
+  const opRowDefs: Record<string, string> = {
+    load: '| `load` | `(entity, reqmatch, ctrl \\\\ nil) :: map()` | Load a single entity by match criteria. Raises on error. |',
+    list: '| `list` | `(entity, reqmatch \\\\ nil, ctrl \\\\ nil) :: list()` | List entities matching the criteria. Raises on error. |',
+    create: '| `create` | `(entity, reqdata, ctrl \\\\ nil) :: map()` | Create a new entity. Raises on error. |',
+    update: '| `update` | `(entity, reqdata, ctrl \\\\ nil) :: map()` | Update an existing entity. Raises on error. |',
+    remove: '| `remove` | `(entity, reqmatch \\\\ nil, ctrl \\\\ nil) :: map()` | Remove an entity. Raises on error. |',
+  }
+  const opRows = ['load', 'list', 'create', 'update', 'remove']
+    .filter((o) => opUnion.has(o)).map((o) => opRowDefs[o]).join('\n')
+
+  const apikeyOptionRow = isAuthActive(model)
+    ? '| `apikey` | `String.t()` | API key for authentication. |\n'
+    : ''
+
+  Content(`### ${Name}
+
+\`\`\`elixir
+sdk = ${Name}.new(options)
+\`\`\`
+
+Creates a new SDK client. \`options\` is a struct value node — build one from a
+native map with \`${Name}.Helpers.deep/1\`.
+
+| Option | Type | Description |
+| --- | --- | --- |
+${apikeyOptionRow}| \`base\` | \`String.t()\` | Base URL of the API server. |
+| \`prefix\` | \`String.t()\` | URL path prefix prepended to all requests. |
+| \`suffix\` | \`String.t()\` | URL path suffix appended to all requests. |
+| \`feature\` | \`map()\` | Feature activation flags. |
+| \`extend\` | \`list()\` | Additional feature instances to load. |
+| \`system\` | \`map()\` | System overrides (e.g. custom \`fetch\` function). |
+
+### test
+
+\`\`\`elixir
+sdk = ${Name}.test(testopts, sdkopts)
+\`\`\`
+
+Creates a test-mode client with mock transport. Both arguments may be \`nil\`.
+
+### ${Name} functions
+
+| Function | Signature | Description |
+| --- | --- | --- |
+| \`options_map\` | \`(client) :: map()\` | Deep copy of current SDK options. |
+| \`get_utility\` | \`(client) :: map()\` | The SDK utility node. |
+| \`prepare\` | \`(client, fetchargs) :: map()\` | Build an HTTP request definition without sending. Raises on error. |
+| \`direct\` | \`(client, fetchargs) :: map()\` | Build and send an HTTP request. Returns a result node (branch on \`ok\`). |
+`)
+
+  each(entityList, (ent: any) => {
+    const article = /^[aeiou]/i.test(ent.Name) ? 'an' : 'a'
+    Content(`| \`${ent.name}\` | \`(client, entopts \\\\ nil) :: entity\` | Create ${article} ${ent.Name} entity handle. |
+`)
+  })
+
+  Content(`
+### Entity interface
+
+Every entity's \`${Name}.Entity.<Name>\` module shares the same interface.
+
+| Function | Signature | Description |
+| --- | --- | --- |
+${opRows}
+| \`data_get\` | \`(entity) :: map()\` | Get entity data. |
+| \`data_set\` | \`(entity, data)\` | Set entity data. |
+| \`match_get\` | \`(entity) :: map()\` | Get entity match criteria. |
+| \`match_set\` | \`(entity, match)\` | Set entity match criteria. |
+| \`make\` | \`(entity) :: entity\` | Create a new handle with the same options. |
+| \`get_name\` | \`(entity) :: String.t()\` | Return the entity name. |
+
+### Result shape
+
+Entity operations return the bare result data (a value node — a map for
+single-entity ops, a list for \`list\`) and raise a \`${Name}.Error\` on
+failure. Wrap calls in \`try\`/\`rescue\` to handle errors.
+
+The \`direct/2\` escape hatch never raises — it returns a result node you
+branch on via \`Voxgig.Struct.getprop(result, "ok")\`:
+
+| Key | Type | Description |
+| --- | --- | --- |
+| \`ok\` | \`boolean()\` | \`true\` if the HTTP status is 2xx. |
+| \`status\` | \`integer()\` | HTTP status code. |
+| \`headers\` | \`map()\` | Response headers. |
+| \`data\` | \`any()\` | Parsed JSON response body. |
+
+On error, \`ok\` is \`false\` and \`err\` carries the error value.
+
+`)
+
+  // Entities summary
+  Content(`### Entities
+
+`)
+  each(entityList, (ent: any) => {
+    const fields = ent.fields || []
+    const opnames = Object.keys(ent.op || {})
+    const ops = ent.op || {}
+    const points = each(ops).map((op: any) =>
+      op.points ? each(op.points) : []
+    ).flat()
+    const path = points.length > 0 ? (points[0] as any).orig || '' : ''
+
+    Content(`#### ${ent.Name}
+
+| Field | Description |
+| --- | --- |
+`)
+    each(fields, (field: any) => {
+      Content(`| \`${field.name}\` | ${field.short || ''} |
+`)
+    })
+
+    Content(`
+Operations: ${opnames.map((n: string) => n.charAt(0).toUpperCase() + n.slice(1)).join(', ')}.
+
+API path: \`${path}\`
+
+`)
+  })
+
+})
+
+
+export {
+  ReadmeModel
+}

package/project/.sdk/src/cmp/elixir/ReadmeOptions_elixir.ts

@@ -0,0 +1,62 @@
+
+import { cmp, each, Content, envName, isAuthActive } from '@voxgig/sdkgen'
+
+
+const ReadmeOptions = cmp(function ReadmeOptions(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+  const Name = model.const.Name
+
+  const publishedOptions = each(target.options).filter((option: any) =>
+    option.publish && ('apikey' !== option.name || isAuthActive(model)))
+  if (0 === publishedOptions.length) {
+    return
+  }
+
+  Content(`
+
+## Options
+
+Pass options when creating a client. Native maps are lifted into the SDK's
+value model by \`${Name}.Helpers.deep/1\`:
+
+`)
+
+  Content(`\`\`\`elixir
+sdk = ${Name}.new(${Name}.Helpers.deep(%{
+`)
+
+  publishedOptions.map((option: any) => {
+    if ('apikey' === option.name) {
+      Content(`  "${option.name}" => System.get_env("${envName(model)}_APIKEY"),
+`)
+    }
+    else {
+      Content(`  # "${option.name}" => ${option.kind === 'string' ? "\"...\"" : '...'},
+`)
+    }
+  })
+
+  Content(`}))
+\`\`\`
+
+`)
+
+  Content(`| Option | Type | Description |
+| --- | --- | --- |
+`)
+
+  publishedOptions.map((option: any) => {
+    Content(`| \`${option.name}\` | \`${option.kind}\` | ${option.short} |
+`)
+  })
+
+  Content(`
+`)
+})
+
+
+export {
+  ReadmeOptions
+}

package/project/.sdk/src/cmp/elixir/ReadmeQuick_elixir.ts

@@ -0,0 +1,198 @@
+
+import { cmp, Content, isAuthActive, envName, opRequestShape, entityIdField, entityDataIdField, entityOps } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+import { elixirLit } from './utility_elixir'
+
+
+const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
+  const { ctx$: { model } } = props
+
+  const Name = model.const.Name
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+
+  const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
+
+  // Find a nested entity if available: one with a parent chain, an active
+  // load op, and a required non-id load param to demonstrate (the parent key).
+  const nestedEntity = Object.values(entity).find((e: any) =>
+    e.active !== false &&
+    e.relations && e.relations.ancestors && 0 < e.relations.ancestors.length &&
+    entityOps(e).includes('load') &&
+    opRequestShape(e, 'load').items.some((it: any) =>
+      !it.optional && it.name !== entityIdField(e))
+  ) as any
+
+  const authActive = isAuthActive(model)
+  const ctor = authActive
+    ? `${Name}.new(H.deep(%{"apikey" => System.get_env("${envName(model)}_APIKEY")}))`
+    : `${Name}.new()`
+
+  Content(`### 1. Create a client
+
+\`\`\`elixir
+alias ${Name}.Helpers, as: H
+
+sdk = ${ctor}
+\`\`\`
+
+`)
+
+  if (exampleEntity) {
+    const eName = nom(exampleEntity, 'Name')
+    const article = /^[aeiou]/i.test(eName) ? 'an' : 'a'
+    const eVar = exampleEntity.name
+    const opnames = entityOps(exampleEntity)
+    const idF = entityIdField(exampleEntity)
+    const dataIdF = entityDataIdField(exampleEntity)
+
+    if (opnames.includes('list')) {
+      Content(`### 2. List ${eName.toLowerCase()} records
+
+\`list/2\` returns a list value node and raises on error.
+
+\`\`\`elixir
+try do
+  ${eVar} = ${Name}.${eVar}(sdk)
+  records = ${Name}.Entity.${eName}.list(${eVar})
+  IO.inspect(records)
+rescue
+  err -> IO.puts("list failed: " <> inspect(err))
+end
+\`\`\`
+
+`)
+    }
+
+    if (nestedEntity) {
+      const neName = nom(nestedEntity, 'Name')
+      const neArticle = /^[aeiou]/i.test(neName) ? 'an' : 'a'
+      const neVar = nestedEntity.name
+
+      const neIdF = entityIdField(nestedEntity)
+      const neRequired = opRequestShape(nestedEntity, 'load').items
+        .filter((it: any) => !it.optional)
+        .sort((a: any, b: any) =>
+          (a.name === neIdF ? 1 : 0) - (b.name === neIdF ? 1 : 0))
+      const parentItem = neRequired.find((it: any) => it.name !== neIdF) as any
+      const parentParam = parentItem && parentItem.name
+      const parentName = parentParam ? parentParam.replace(/_id$/, '') : 'its parent'
+      const neMatch = neRequired.map((it: any) =>
+        `"${it.name}" => ${elixirLit(it.type,
+          it.name === neIdF ? 'example_id' : 'example_' + it.name)}`)
+
+      Content(`### 3. Load ${neArticle} ${neName.toLowerCase()}
+
+${neName} is nested under ${parentName}, so provide the \`${parentParam}\`.
+\`load/2\` returns the bare record and raises on error.
+
+\`\`\`elixir
+try do
+  ${neVar} = ${Name}.${neVar}(sdk)
+  record = ${Name}.Entity.${neName}.load(${neVar}, H.deep(%{${neMatch.join(', ')}}))
+  IO.inspect(record)
+rescue
+  err -> IO.puts("load failed: " <> inspect(err))
+end
+\`\`\`
+
+`)
+    }
+    else if (opnames.includes('load')) {
+      const loadRequired = opRequestShape(exampleEntity, 'load').items
+        .filter((it: any) => !it.optional || it.name === idF)
+        .sort((a: any, b: any) =>
+          (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
+      const loadArg = 0 < loadRequired.length
+        ? `H.deep(%{${loadRequired.map((it: any) =>
+          `"${it.name}" => ${elixirLit(it.type,
+            it.name === idF ? 'example_id' : 'example_' + it.name)}`).join(', ')}})`
+        : 'H.deep(%{})'
+
+      Content(`### 3. Load ${article} ${eName.toLowerCase()}
+
+\`load/2\` returns the bare record and raises on error.
+
+\`\`\`elixir
+try do
+  ${eVar} = ${Name}.${eVar}(sdk)
+  record = ${Name}.Entity.${eName}.load(${eVar}, ${loadArg})
+  IO.inspect(record)
+rescue
+  err -> IO.puts("load failed: " <> inspect(err))
+end
+\`\`\`
+
+`)
+    }
+
+    // Model-driven example fields: derive the create/update body from the op
+    // shape so the docs reference REAL writable fields.
+    const examplePairs = (opname: string): string[] => {
+      const items = opRequestShape(exampleEntity, opname).items
+        .filter((it: any) => (it.name !== idF && it.name !== 'id') ||
+          ('create' === opname && !it.optional))
+      const required = items.filter((it: any) => !it.optional)
+      const optional = items.filter((it: any) => it.optional)
+      const chosen = 'create' === opname
+        ? (required.length ? required : items.slice(0, 2))
+        : required.concat(optional).slice(0, Math.max(2, required.length))
+      return chosen.map((it: any) => `"${it.name}" => ${elixirLit(it.type, 'example_' + it.name)}`)
+    }
+
+    const idParamType = (opname: string): any => {
+      const it = opRequestShape(exampleEntity, opname).items.find((x: any) => x.name === idF)
+      return it && it.type
+    }
+    const idValueFor = (opname: string): string => (null != dataIdF && opnames.includes('create'))
+      ? `Voxgig.Struct.getprop(created, "${dataIdF}")`
+      : elixirLit(idParamType(opname), 'example_id')
+
+    if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {
+      Content(`### 4. Create, update, and remove
+
+\`\`\`elixir
+${eVar} = ${Name}.${eVar}(sdk)
+
+`)
+      if (opnames.includes('create')) {
+        Content(`# Create — returns the bare created record
+created = ${Name}.Entity.${eName}.create(${eVar}, H.deep(%{${examplePairs('create').join(', ')}}))
+
+`)
+      }
+      if (opnames.includes('update')) {
+        const updatePairs = (idF ? [`"${idF}" => ${idValueFor('update')}`] : []).concat(examplePairs('update'))
+        Content(`# Update
+${Name}.Entity.${eName}.update(${eVar}, H.deep(%{${updatePairs.join(', ')}}))
+
+`)
+      }
+      if (opnames.includes('remove')) {
+        const removePairs = opRequestShape(exampleEntity, 'remove').items
+          .filter((it: any) => !it.optional || it.name === idF)
+          .sort((a: any, b: any) =>
+            (a.name === idF ? 0 : 1) - (b.name === idF ? 0 : 1))
+          .map((it: any) => it.name === idF
+            ? `"${it.name}" => ${idValueFor('remove')}`
+            : `"${it.name}" => ${elixirLit(it.type, 'example_' + it.name)}`)
+        Content(`# Remove
+${Name}.Entity.${eName}.remove(${eVar}${removePairs.length ? `, H.deep(%{${removePairs.join(', ')}})` : ''})
+`)
+      }
+      Content(`\`\`\`
+
+`)
+    }
+  }
+})
+
+
+export {
+  ReadmeQuick
+}