@voxgig/sdkgen 1.2.0 → 1.3.1

package/project/.sdk/src/cmp/py/ReadmeTopHowto_py.ts

@@ -7,7 +7,7 @@ const ReadmeTopHowto = cmp(function ReadmeTopHowto(props: any) {
 
   Content(`**Python:**
 \`\`\`python
-result, err = client.direct({
+result = client.direct({
     "path": "/api/resource/{id}",
     "method": "GET",
     "params": {"id": "example"},

package/project/.sdk/src/cmp/py/ReadmeTopQuick_py.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content, isAuthActive } from '@voxgig/sdkgen'
+import { cmp, Content, isAuthActive, envName, entityIdField } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -17,34 +17,42 @@ const ReadmeTopQuick = cmp(function ReadmeTopQuick(props: any) {
 
   const authActive = isAuthActive(model)
   const apikeyImport = authActive ? `import os\n` : ''
-  const apikeyArg = authActive
-    ? `\n    "apikey": os.environ.get("${model.NAME}_APIKEY"),\n`
-    : ''
+  const ctor = authActive
+    ? `${model.const.Name}SDK({\n    "apikey": os.environ.get("${envName(model)}_APIKEY"),\n})`
+    : `${model.const.Name}SDK()`
 
   Content(`\`\`\`python
 ${apikeyImport}from ${model.const.Name.toLowerCase()}_sdk import ${model.const.Name}SDK
 
-client = ${model.const.Name}SDK({${apikeyArg}})
+client = ${ctor}
 
 `)
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
     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.
+    const idF = entityIdField(exampleEntity)
+
+    let hasCall = false
 
     if (opnames.includes('list')) {
-      Content(`# List all ${eName.toLowerCase()}s
-${eName.toLowerCase()}s, err = client.${eName}(None).list(None, None)
+      Content(`# List all ${eName.toLowerCase()}s (returns a list, raises on error)
+${eName.toLowerCase()}s = client.${eName}().list()
+for ${eName.toLowerCase()} in ${eName.toLowerCase()}s:
+    print(${eName.toLowerCase()})
 `)
+      hasCall = true
     }
 
     if (opnames.includes('load')) {
       Content(`
-# Load a specific ${eName.toLowerCase()}
-${eName.toLowerCase()}, err = client.${eName}(None).load(
-    {"id": "example_id"}, None
-)
+# Load a specific ${eName.toLowerCase()} (returns the record, raises on error)
+${eName.toLowerCase()} = client.${eName}().load(${idF ? `{"${idF}": "example_id"}` : ''})
+print(${eName.toLowerCase()})
 `)
+      hasCall = true
     }
   }
 

package/project/.sdk/src/cmp/py/ReadmeTopTest_py.ts

@@ -1,5 +1,5 @@
 
-import { cmp, Content } from '@voxgig/sdkgen'
+import { cmp, Content, canonKey, entityIdField, entityPrimaryOp, opRequestShape } from '@voxgig/sdkgen'
 
 import {
   KIT,
@@ -8,6 +8,17 @@ import {
 } from '@voxgig/apidef'
 
 
+// A type-correct Python literal for a field's canonical type.
+function pyLit(type: any): string {
+  const k = canonKey(type)
+  if ('INTEGER' === k || 'NUMBER' === k) return '1'
+  if ('BOOLEAN' === k) return 'True'
+  if ('ARRAY' === k) return '[]'
+  if ('OBJECT' === k) return '{}'
+  return '"example"'
+}
+
+
 const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   const { target, ctx$: { model } } = props
 
@@ -16,14 +27,28 @@ const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
   Content(`\`\`\`python
-client = ${model.const.Name}SDK.test(None, None)
+client = ${model.const.Name}SDK.test()
 `)
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
-    Content(`result, err = client.${eName}(None).load(
-    {"id": "test01"}, None
-)
+    // 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 = ''
+    if (isMatchOp) {
+      arg = idF ? `{"${idF}": "test01"}` : ''
+    } 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 = `{${chosen.map((it: any) => `"${it.name}": ${pyLit(it.type)}`).join(', ')}}`
+    }
+    Content(`${eName.toLowerCase()} = client.${eName}().${primaryOp}(${arg})
+print(${eName.toLowerCase()})
 `)
   }
 

package/project/.sdk/src/cmp/py/TestDirect_py.ts

@@ -192,7 +192,7 @@ ${listSkipBlock}        client = setup["client"]
 `)
         }
         Content(`
-        result, err = client.direct({
+        result = client.direct({
             "path": "${listPath}",
             "method": "GET",
             "params": params,
@@ -200,7 +200,7 @@ ${listSkipBlock}        client = setup["client"]
 `)
       } else {
         Content(`
-        result, err = client.direct({
+        result = client.direct({
             "path": "${listPath}",
             "method": "GET",
             "params": {},
@@ -212,8 +212,8 @@ ${listSkipBlock}        client = setup["client"]
             # Live mode is lenient: synthetic IDs frequently 4xx and the
             # list-response shape varies wildly across public APIs. Skip
             # rather than fail when the call doesn't return a usable list.
-            if err is not None:
-                pytest.skip(f"list call failed (likely synthetic IDs against live API): {err}")
+            if result.get("err") is not None:
+                pytest.skip(f"list call failed (likely synthetic IDs against live API): {result.get('err')}")
                 return
             if not result.get("ok"):
                 pytest.skip("list call not ok (likely synthetic IDs against live API)")
@@ -223,7 +223,6 @@ ${listSkipBlock}        client = setup["client"]
                 pytest.skip(f"expected 2xx status, got {status}")
                 return
         else:
-            assert err is None
             assert result["ok"] is True
             assert helpers.to_int(result["status"]) == 200
             assert isinstance(result["data"], list)
@@ -291,7 +290,7 @@ ${loadLiveQueryLines}
       }
 
       Content(`
-        result, err = client.direct({
+        result = client.direct({
             "path": "${loadPath}",
             "method": "GET",
 `)
@@ -308,8 +307,8 @@ ${loadLiveQueryLines}
             # Live mode is lenient: synthetic IDs frequently 4xx. Skip
             # rather than fail when the load endpoint isn't reachable
             # with the IDs we can construct from setup.idmap.
-            if err is not None:
-                pytest.skip(f"load call failed (likely synthetic IDs against live API): {err}")
+            if result.get("err") is not None:
+                pytest.skip(f"load call failed (likely synthetic IDs against live API): {result.get('err')}")
                 return
             if not result.get("ok"):
                 pytest.skip("load call not ok (likely synthetic IDs against live API)")
@@ -319,7 +318,6 @@ ${loadLiveQueryLines}
                 pytest.skip(f"expected 2xx status, got {status}")
                 return
         else:
-            assert err is None
             assert result["ok"] is True
             assert helpers.to_int(result["status"]) == 200
             assert result["data"] is not None

package/project/.sdk/src/cmp/py/TestEntity_py.ts

@@ -272,9 +272,7 @@ const generateCreate: OpGen = (ctx, step, index) => {
   const hasEntIdC = null != ctx.entity.id
 
   Content(`
-        ${datavar}_result, err = ${entvar}.create(${datavar}, None)
-        assert err is None
-        ${datavar} = helpers.to_map(${datavar}_result)
+        ${datavar} = helpers.to_map(${entvar}.create(${datavar}, None))
         assert ${datavar} is not None
 `)
   if (hasEntIdC) {
@@ -318,8 +316,7 @@ const generateList: OpGen = (ctx, step, index) => {
   }
 
   Content(`
-        ${listvar}_result, err = ${entvar}.list(${matchvar}, None)
-        assert err is None
+        ${listvar}_result = ${entvar}.list(${matchvar}, None)
         assert isinstance(${listvar}_result, list)
 `)
 
@@ -407,9 +404,7 @@ const generateUpdate: OpGen = (ctx, step, index) => {
   }
 
   Content(`
-        ${resdatavar}_result, err = ${entvar}.update(${datavar}_up, None)
-        assert err is None
-        ${resdatavar} = helpers.to_map(${resdatavar}_result)
+        ${resdatavar} = helpers.to_map(${entvar}.update(${datavar}_up, None))
         assert ${resdatavar} is not None
 `)
   if (hasEntIdU) {
@@ -472,8 +467,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
     Content(`        ${matchvar} = {
             "id": ${srcdatavar}["id"],
         }
-        ${datavar}_loaded, err = ${entvar}.load(${matchvar}, None)
-        assert err is None
+        ${datavar}_loaded = ${entvar}.load(${matchvar}, None)
         ${datavar}_load_result = helpers.to_map(${datavar}_loaded)
         assert ${datavar}_load_result is not None
         assert ${datavar}_load_result["id"] == ${srcdatavar}["id"]
@@ -481,8 +475,7 @@ const generateLoad: OpGen = (ctx, step, index) => {
   }
   else {
     Content(`        ${matchvar} = {}
-        ${datavar}_loaded, err = ${entvar}.load(${matchvar}, None)
-        assert err is None
+        ${datavar}_loaded = ${entvar}.load(${matchvar}, None)
         assert ${datavar}_loaded is not None
 `)
   }
@@ -510,8 +503,7 @@ const generateRemove: OpGen = (ctx, step, index) => {
   Content(`        ${matchvar} = {
             "id": ${srcdatavar}["id"],
         }
-        _, err = ${entvar}.remove(${matchvar}, None)
-        assert err is None
+        ${entvar}.remove(${matchvar}, None)
 `)
 }
 

package/project/.sdk/src/cmp/py/Test_py.ts

@@ -13,6 +13,7 @@ import { cmp, each, Folder, File, Content } from '@voxgig/sdkgen'
 
 import { TestEntity } from './TestEntity_py'
 import { TestDirect } from './TestDirect_py'
+import { ReadmeExamplesTest } from './ReadmeExamplesTest_py'
 
 
 const Test = cmp(function Test(props: any) {
@@ -46,6 +47,9 @@ class TestExists:
       TestEntity({ target, entity })
       TestDirect({ target, entity })
     })
+
+    // Validate the documented python examples in the root README.
+    ReadmeExamplesTest({ target })
   })
 })
 

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

@@ -1,7 +1,10 @@
 # ProjectName SDK EntityName entity
 
+from __future__ import annotations
+
 from utility.voxgig_struct import voxgig_struct as vs
 from core import helpers
+# #TypeImports
 
 
 class EntityNameEntity:
@@ -44,7 +47,7 @@ class EntityNameEntity:
             self._data = helpers.to_map(vs.clone(args)) or {}
             self._utility.feature_hook(self._entctx, "SetData")
 
-    def data_get(self):
+    def data_get(self) -> EntityName:
         self._utility.feature_hook(self._entctx, "GetData")
         return vs.clone(self._data)
 
@@ -53,7 +56,7 @@ class EntityNameEntity:
             self._match = helpers.to_map(vs.clone(args)) or {}
             self._utility.feature_hook(self._entctx, "SetMatch")
 
-    def match_get(self):
+    def match_get(self) -> EntityName:
         self._utility.feature_hook(self._entctx, "GetMatch")
         return vs.clone(self._match)
 

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

@@ -5,7 +5,7 @@ entity_create_op = None
 
 # EJECT-START
 
-    def create(self, reqdata, ctrl=None):
+    def create(self, reqdata: EntityNameCreateData, ctrl=None) -> EntityName:
         utility = self._utility
         ctx = utility.make_context({
             "opname": "create",

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

@@ -2,8 +2,12 @@ entity_list_op = None
 
 # EJECT-START
 
-    def list(self, reqmatch, ctrl=None):
+    def list(self, reqmatch=None, ctrl=None) -> list[EntityName]:
         utility = self._utility
+        # reqmatch is optional: an omitted match lists all records. Treat None
+        # as an empty match so client.EntityName().list() works with no args.
+        if reqmatch is None:
+            reqmatch = {}
         ctx = utility.make_context({
             "opname": "list",
             "ctrl": ctrl,

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

@@ -5,8 +5,13 @@ entity_load_op = None
 
 # EJECT-START
 
-    def load(self, reqmatch, ctrl=None):
+    def load(self, reqmatch=None, ctrl=None) -> EntityName:
         utility = self._utility
+        # reqmatch is optional: an entity with no id-like key loads with no
+        # match. Treat None as an empty match so client.EntityName().load()
+        # works with no args.
+        if reqmatch is None:
+            reqmatch = {}
         ctx = utility.make_context({
             "opname": "load",
             "ctrl": ctrl,

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

@@ -5,8 +5,13 @@ entity_remove_op = None
 
 # EJECT-START
 
-    def remove(self, reqmatch, ctrl=None):
+    def remove(self, reqmatch=None, ctrl=None) -> EntityName:
         utility = self._utility
+        # reqmatch is optional: an entity with no id-like key removes with no
+        # match. Treat None as an empty match so client.EntityName().remove()
+        # works with no args.
+        if reqmatch is None:
+            reqmatch = {}
         ctx = utility.make_context({
             "opname": "remove",
             "ctrl": ctrl,

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

@@ -5,7 +5,7 @@ entity_update_op = None
 
 # EJECT-START
 
-    def update(self, reqdata, ctrl=None):
+    def update(self, reqdata: EntityNameUpdateData, ctrl=None) -> EntityName:
         utility = self._utility
         ctx = utility.make_context({
             "opname": "update",

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

@@ -144,16 +144,23 @@ class ProjectNameSDK:
 
         _, err = utility.prepare_auth(ctx)
         if err is not None:
-            return None, err
+            raise err
 
-        return utility.make_fetch_def(ctx)
+        fetchdef, err = utility.make_fetch_def(ctx)
+        if err is not None:
+            raise err
+
+        return fetchdef
 
     def direct(self, fetchargs=None):
         utility = self._utility
 
-        fetchdef, err = self.prepare(fetchargs)
-        if err is not None:
-            return {"ok": False, "err": err}, None
+        try:
+            fetchdef = self.prepare(fetchargs)
+        except Exception as err:
+            # direct() is the raw-HTTP escape hatch: it never raises, it
+            # returns a result object callers branch on via result["ok"].
+            return {"ok": False, "err": err}
 
         if fetchargs is None:
             fetchargs = {}
@@ -170,13 +177,13 @@ class ProjectNameSDK:
         fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
 
         if fetch_err is not None:
-            return {"ok": False, "err": fetch_err}, None
+            return {"ok": False, "err": fetch_err}
 
         if fetched is None:
             return {
                 "ok": False,
                 "err": ctx.make_error("direct_no_response", "response: undefined"),
-            }, None
+            }
 
         if isinstance(fetched, dict):
             status = helpers.to_int(vs.getprop(fetched, "status"))
@@ -205,17 +212,17 @@ class ProjectNameSDK:
                 "status": status,
                 "headers": headers,
                 "data": json_data,
-            }, None
+            }
 
         return {
             "ok": False,
             "err": ctx.make_error("direct_invalid", "invalid response type"),
-        }, None
+        }
 
     # <[SLOT]>
 
     @classmethod
-    def test(cls, testopts=None, sdkopts=None):
+    def test(cls, testopts=None, sdkopts=None) -> "ProjectNameSDK":
         if sdkopts is None:
             sdkopts = {}
         sdkopts = vs.clone(sdkopts)

package/project/.sdk/src/cmp/rb/EntityTypes_rb.ts

@@ -0,0 +1,136 @@
+
+
+// Typed-model generator (Ruby target).
+//
+// Ported from the TypeScript reference EntityTypes_ts.ts. Reads
+// main.<KIT>.entity.<e>.fields[] and per-op params (op.<name>.points[].args.params[])
+// and emits one file, <Sdk>_types.rb, containing a keyword-init Struct per active
+// entity plus a request/match Struct per active op. Ruby has no enforced static
+// types, so each member carries a YARD `@!attribute`/`@return` annotation whose
+// element type comes from the canonical sentinels via the shared sdkgen helper
+// `canonToType` (source of truth: @voxgig/apidef VALID_CANON):
+//   $STRING -> String, $INTEGER -> Integer, $NUMBER -> Float, $BOOLEAN -> Boolean,
+//   $OBJECT -> Hash, $ARRAY -> Array, unknown -> Object.
+//
+// Type-name scheme (IDENTICAL to TS): data type = <Name>; per-op request
+// <Name>LoadMatch / <Name>ListMatch / <Name>RemoveMatch (query/id ops),
+// <Name>CreateData / <Name>UpdateData (body ops). An op WITH params -> a Struct of
+// those params (reqd:false -> annotated `[Type, nil]`). An op WITHOUT params -> a
+// Struct over the entity fields (Struct members are always optional/nil, so this is
+// the Ruby stand-in for TS `Partial<Name>`; callers may equally pass a plain Hash).
+//
+// Struct.new(keyword_init: true) gives value objects usable as `Advice.new(id: ...)`.
+// The file is required by the main SDK module so these constants are always loaded.
+
+import {
+  cmp, each,
+  File, Content,
+} from '@voxgig/sdkgen'
+
+import { canonToType, opTypeName, opRequestShape } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+const LANG = 'rb'
+
+
+// A Ruby symbol literal for a member name: bare for identifiers, quoted otherwise.
+function symName(name: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_]*[?!=]?$/.test(name) ? ':' + name : ':"' + name + '"'
+}
+
+
+// Emit one typed value class: a YARD @!attribute block plus a keyword-init
+// Struct. Ruby's `Struct.new` rejects zero members, so an empty shape falls
+// back to a plain empty class (keeps the type name available).
+function emitStruct(
+  typeName: string,
+  doc: string,
+  members: Array<{ name: string, type: unknown, optional: boolean }>,
+) {
+  let block = `# ${doc}\n`
+
+  members.forEach((m) => {
+    const t = canonToType(m.type, LANG)
+    const ret = m.optional ? `[${t}, nil]` : `[${t}]`
+    block += `#\n# @!attribute [rw] ${m.name}\n#   @return ${ret}\n`
+  })
+
+  if (0 === members.length) {
+    block += `class ${typeName}\nend\n\n`
+    Content(block)
+    return
+  }
+
+  block += `${typeName} = Struct.new(\n`
+  members.forEach((m) => {
+    block += `  ${symName(m.name)},\n`
+  })
+  block += `  keyword_init: true\n)\n\n`
+
+  Content(block)
+}
+
+
+const EntityTypes = cmp(function EntityTypes(props: any) {
+  const { model } = props.ctx$
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const entityList = each(entity).filter((e: any) => e.active !== false)
+
+  File({ name: model.const.Name + '_types.' + LANG }, () => {
+
+    Content(`# frozen_string_literal: true
+
+# Typed models for the ${model.const.Name} SDK.
+#
+# GENERATED from the API model: main.${KIT}.entity.<e>.fields[] and per-op
+# params (op.<name>.points[].args.params[]). Member types come from the
+# canonical type sentinels via @voxgig/sdkgen canonToType (source of truth:
+# @voxgig/apidef VALID_CANON). Ruby types are unenforced; these YARD
+# annotations document the shapes. Do not edit by hand.
+
+`)
+
+    entityList.forEach((ent: any) => {
+      const Name = ent.Name
+      const fields = (ent.fields ? each(ent.fields) : [])
+        .filter((f: any) => f.active !== false)
+
+      // Entity data model: one member per field (`req:false` -> nilable).
+      emitStruct(
+        Name,
+        `${Name} entity data model.`,
+        fields.map((f: any) => ({ name: f.name, type: f.type, optional: false === f.req })),
+      )
+
+      // Per active op: a request/match Struct. Members and their optionality
+      // come from the shared partiality policy (opRequestShape); this file only
+      // renders them as a keyword-init Struct.
+      const ops = ent.op || {}
+      ;['load', 'list', 'create', 'update', 'remove'].forEach((opname: string) => {
+        if (null == ops[opname]) {
+          return
+        }
+
+        const typeName = opTypeName(Name, opname)
+        const { items } = opRequestShape(ent, opname)
+
+        emitStruct(
+          typeName,
+          `Request payload for ${Name}#${opname}.`,
+          items,
+        )
+      })
+    })
+  })
+})
+
+
+export {
+  EntityTypes,
+}

package/project/.sdk/src/cmp/rb/MainEntity_rb.ts

@@ -8,6 +8,7 @@ const MainEntity = cmp(async function MainEntity(props: any) {
   const { model } = props.ctx$
 
   Content(`
+  # Canonical facade: client.${entity.Name}.list / client.${entity.Name}.load({ "id" => ... })
   def ${entity.Name}(data = nil)
     require_relative 'entity/${entity.name}_entity'
     ${entity.Name}Entity.new(self, data)

package/project/.sdk/src/cmp/rb/Main_rb.ts

@@ -22,6 +22,7 @@ import { Package } from './Package_rb'
 import { Config } from './Config_rb'
 import { Gitignore } from './Gitignore_rb'
 import { MainEntity } from './MainEntity_rb'
+import { EntityTypes } from './EntityTypes_rb'
 
 
 const Main = cmp(async function Main(props: any) {
@@ -84,6 +85,9 @@ utility.feature_hook.call(@_rootctx, "${name}")
     Config({ target })
   })
 
+  // Generate typed models (<Sdk>_types.rb) — required by the main SDK file.
+  EntityTypes({ target })
+
   // Generate feature factory module
   File({ name: 'features.' + target.ext }, () => {
     Content(`# ${model.const.Name} SDK feature factory

package/project/.sdk/src/cmp/rb/Package_rb.ts

@@ -4,6 +4,8 @@ import {
   File,
   cmp,
   collectDeps,
+  pkgDescription,
+  repoInfo,
 } from '@voxgig/sdkgen'
 
 
@@ -24,6 +26,7 @@ const Package = cmp(async function Package(props: any) {
   const ns = model.origin || 'voxgig-sdk'
   const pkgBase = ns.endsWith('-sdk') ? model.name : `${model.name}-sdk`
   const gemName = `${ns}-${pkgBase}`
+  const { repoUrl, issuesUrl, changelogUrl } = repoInfo(model)
 
   const versionOf = (d: { version: string; source: 'feature' | 'target' }) =>
     d.source === 'target' ? (d.version || '0.0') : d.version
@@ -44,23 +47,47 @@ gemspec
 
   // Generate gemspec
   File({ name: model.const.Name + '_sdk.gemspec' }, () => {
+    // RubyGems rejects a gemspec that declares the same runtime dependency
+    // twice (Gem::InvalidSpecificationException at `gem build`), so the
+    // unconstrained json fallback is only emitted when the model's own
+    // dependency list doesn't already declare json.
+    const deps = collectDeps(model, target.name, target.deps)
+    const hasJson = deps.some((d: any) => 'json' === d.name)
+
     Content(`Gem::Specification.new do |spec|
   spec.name          = "${gemName}"
   spec.version       = "0.0.1"
   spec.authors       = ["Voxgig"]
-  spec.summary       = "${model.const.Name} SDK for Ruby"
+  spec.summary       = "${pkgDescription(model, 'rb')}"
+  spec.description   = "${pkgDescription(model, 'rb')}"
   spec.license       = "MIT"
-  spec.homepage      = "https://github.com/${ns}/${model.name}-sdk"
-
-  spec.files         = Dir["lib/**/*.rb", "*.rb"]
+  spec.homepage      = "${repoUrl}"
+  spec.metadata      = {
+    "homepage_uri"          => "${repoUrl}",
+    "source_code_uri"       => "${repoUrl}",
+    "bug_tracker_uri"       => "${issuesUrl}",
+    "changelog_uri"         => "${changelogUrl}",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files         = Dir[
+    "*.rb",
+    "core/**/*.rb",
+    "entity/**/*.rb",
+    "feature/**/*.rb",
+    "utility/**/*.rb",
+    "LICENSE",
+    "README.md",
+    "REFERENCE.md"
+  ]
   spec.require_paths = ["."]
 
   spec.required_ruby_version = ">= 3.0"
-
+${hasJson ? '' : `
   spec.add_dependency "json"
-`)
+`}`)
 
-    for (const d of collectDeps(model, target.name, target.deps)) {
+    for (const d of deps) {
       Content(`  spec.add_dependency "${d.name}", "~> ${versionOf(d)}"
 `)
     }