@voxgig/sdkgen 3.5.1 → 3.7.0

package/src/helpers/packageMeta.ts

@@ -40,6 +40,27 @@ function langLabel(target: string): string {
   return LANG_LABEL[target] || target
 }
 
+
+// THE NAME WHOSE LANGUAGE RULES APPLY.
+//
+// A target name does two unrelated jobs in this file, and conflating them is
+// the defect this exists to end. `go~go2` installs a SECOND Go SDK: its
+// CONFIG lives under `main.kit.target.go2` (its own module path, its own
+// registry state), but it is still Go — the same go.mod shape, the same
+// `go get` install line, the same "Go" label.
+//
+// So: look config up by the target's OWN name, and select behaviour by this.
+// `origname` is stamped at add time precisely for aliased installs and is
+// empty when a target was installed under its own name, which makes the
+// unaliased case identical to what it was.
+//
+// Ecosystem keys ('npm', 'gem', 'composer') pass through untouched: there is
+// no target node under those names, so they answer for themselves.
+function originName(model: any, target: string): string {
+  const orig = model?.main?.[KIT]?.target?.[target]?.origname
+  return (null != orig && '' !== orig) ? String(orig) : target
+}
+
 // Git host, org/repo path, and the canonical repo URLs.
 //
 // `<origin>/<slug>-sdk` is a DERIVATION, not a law. A project whose repo is
@@ -185,7 +206,10 @@ function goPackageIdent(model: any, target: string): string {
 // The legacy boolean `registry.active: true` is honoured as a back-compat
 // alias for state === 'active'.
 function registryState(model: any, target: string): 'tag' | 'pending' | 'active' | 'inactive' {
-  if ('go' === target || 'go-cli' === target || 'go-mcp' === target) return 'tag'
+  // Tag-only is a property of the Go toolchain, not of one target name, so
+  // an aliased `go~go2` must be tag-only too.
+  const eco = originName(model, target)
+  if ('go' === eco || 'go-cli' === eco || 'go-mcp' === eco) return 'tag'
   const reg = model?.main?.[KIT]?.target?.[target]?.publish?.registry
   if (null == reg || '' === (reg.name || '')) return 'tag'
   if (true === reg.active) return 'active' // legacy alias
@@ -215,13 +239,16 @@ function registryName(model: any, target: string): string {
 // pointer carrying the releases URL.
 function vendorCommand(model: any, target: string): string {
   const { releasesUrl } = repoInfo(model)
-  switch (target) {
+  switch (originName(model, target)) {
+    // `target`, not the literal — the case says WHICH command, the argument
+    // says whose module. Writing the literal here reintroduces the same bug
+    // the switch above exists to fix, one level down, which is exactly what
+    // the first cut of this change did.
     case 'go':
-      return `go get ${packageName(model, 'go')}@latest`
     case 'go-mcp':
-      return `go get ${packageName(model, 'go-mcp')}@latest`
+      return `go get ${packageName(model, target)}@latest`
     case 'go-cli':
-      return `go install ${packageName(model, 'go-cli')}/cmd/${model.name}@latest`
+      return `go install ${packageName(model, target)}/cmd/${model.name}@latest`
     default: {
       const reg = registryName(model, target)
       return `not yet on ${reg || 'the registry'} — install from the git tag: ${releasesUrl}`
@@ -266,7 +293,12 @@ function packageName(model: any, eco: string): string {
     return String(declared)
   }
 
-  switch (eco) {
+  // The lookup above is keyed by the target's OWN name, so an alias reads its
+  // own declared package. The switch below is about FORM — npm scoping,
+  // slash-separated composer names — which belongs to the language, so it
+  // follows the origin. Passing `ts2` here without this would miss every case
+  // and fall to `default`, silently publishing under a non-npm name.
+  switch (originName(model, eco)) {
     case 'npm':
     case 'ts':
       return npmScoped
@@ -282,12 +314,13 @@ function packageName(model: any, eco: string): string {
     case 'composer':
     case 'php':
       return `${origin}/${base}`
+    // `eco`, not the literal: the case is chosen by the LANGUAGE but the
+    // module belongs to the target that asked. `packageName(model, 'go2')`
+    // returning go's module was the same conflation one level down.
     case 'go':
-      return goModule(model, 'go')
     case 'go-cli':
-      return goModule(model, 'go-cli')
     case 'go-mcp':
-      return goModule(model, 'go-mcp')
+      return goModule(model, eco)
     // The notebook/analyst package layered on `py`. Distinct PyPI name so it
     // can version and publish independently of the SDK it wraps.
     case 'py-data':
@@ -306,25 +339,29 @@ function installCommand(model: any, target: string): string {
   if (!isPublished(model, target)) {
     return vendorCommand(model, target)
   }
-  switch (target) {
+  // WHICH package manager is the language's business, so the switch follows
+  // the origin; WHICH package name is this target's own, so every arm passes
+  // `target` rather than a hardcoded ecosystem key. Before, an aliased
+  // `ts~ts2` matched no case and returned '' — a README with an empty install
+  // line — and even had it matched, `packageName(model, 'npm')` would have
+  // printed the ORIGIN's package.
+  switch (originName(model, target)) {
     case 'ts':
-      return `npm install ${packageName(model, 'npm')}`
     case 'js':
-      return `npm install ${packageName(model, 'js')}`
+      return `npm install ${packageName(model, target)}`
     case 'py':
-      return `pip install ${packageName(model, 'pypi')}`
     case 'py-data':
-      return `pip install ${packageName(model, 'py-data')}`
+      return `pip install ${packageName(model, target)}`
     case 'php':
-      return `composer require ${packageName(model, 'composer')}`
+      return `composer require ${packageName(model, target)}`
     case 'rb':
-      return `gem install ${packageName(model, 'gem')}`
+      return `gem install ${packageName(model, target)}`
     case 'lua':
-      return `luarocks install ${packageName(model, 'luarocks')}`
+      return `luarocks install ${packageName(model, target)}`
     case 'go':
-      return `go get ${packageName(model, 'go')}`
+      return `go get ${packageName(model, target)}`
     case 'go-cli':
-      return `go install ${packageName(model, 'go-cli')}/cmd/${model.name}@latest`
+      return `go install ${packageName(model, target)}/cmd/${model.name}@latest`
     default:
       return ''
   }
@@ -333,7 +370,8 @@ function installCommand(model: any, target: string): string {
 // The standard one-line package description (with the generic non-affiliation
 // statement inline) used in every manifest.
 function pkgDescription(model: any, target: string): string {
-  return `Unofficial generated ${langLabel(target)} SDK for the ${apiName(model)} public API.` +
+  return `Unofficial generated ${langLabel(originName(model, target))} SDK` +
+    ` for the ${apiName(model)} public API.` +
     ` Not affiliated with or endorsed by the upstream API provider.`
 }
 
@@ -437,6 +475,7 @@ export {
   GENERATOR_URL,
   LANG_LABEL,
   langLabel,
+  originName,
   repoInfo,
   apiName,
   packageName,

package/src/sdkgen.ts

@@ -10,7 +10,6 @@ import { Aontu } from 'aontu'
 
 import {
   showChanges,
-  getdlog,
 } from '@voxgig/util'
 
 import type {
@@ -60,7 +59,7 @@ import { collectDeps } from './helpers/collectDeps'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonToDtype, canonKey } from './helpers/canonType'
 import { OP_SUFFIX, opTypeName, opParams, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
-import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
+import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, phpSafeTypeName, isTsReservedType, tsSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
 import { serverVariables, hasServerVariables } from './helpers/serverVars'
 import { primaryOpCall, idLiteral, matchArg, dataArg, litFor } from './helpers/opExample'
 import type { ExampleLang } from './helpers/opExample'
@@ -108,6 +107,7 @@ import {
   repoInfo,
   apiName,
   langLabel,
+  originName,
   PUBLISHER,
   PUBLISHER_URL,
   SECURITY_EMAIL,
@@ -176,7 +176,38 @@ type SdkGenOptions = {
 const { Jostraca } = JostracaModule
 
 
-const dlog = getdlog('sdkgen', __filename)
+// A BROKEN PROJECT MODEL IS THE USER'S FILE, NOT A CRASH.
+//
+// One constructor for both routes out of `resolveModel` — the throw aontu
+// actually takes, and the `errs` array it documents but never fills — because
+// two spellings of the same error is how this repo keeps reintroducing the
+// same defect.
+//
+// aontu's own diagnostic is the valuable part and is passed through
+// UNTOUCHED: it carries the source excerpt, a caret under the offending
+// token, and an explanation. What it lacks is any statement of WHOSE file
+// this is, so the path leads. Wrapping it in an SdkGenError is what makes the
+// CLI print it as a message instead of dumping the error object and a stack
+// trace through sdkgen's internals — `handleError` reserves clean output for
+// that name.
+function modelError(path: string, cause: any, rooterrs: any[]): any {
+  const detail = String(cause?.msg ?? cause?.message ?? cause ?? '').trim()
+
+  const err: any = new SdkGenError(
+    'Model Error: ' + path + '\n' + detail)
+
+  err.cause$ = [cause]
+  err.rooterrs$ = rooterrs
+
+  // A syntax error is the user's typo, and there is nothing for them to do
+  // with a stack. `why` lives on the structured entries rather than the
+  // thrown wrapper, so it is read from the first of them.
+  if ('syntax' === (cause?.why ?? rooterrs?.[0]?.why)) {
+    err.uxmsg$ = true
+  }
+
+  return err
+}
 
 
 function SdkGen(opts: SdkGenOptions) {
@@ -393,13 +424,6 @@ function SdkGen(opts: SdkGenOptions) {
       showChanges(jopts.log, 'generate-result', eres, Path.dirname(process.cwd()))
     }
 
-    const dlogs = dlog.log()
-    if (0 < dlogs.length) {
-      for (let dlogentry of dlogs) {
-        log.debug({ point: 'generate-warning', dlogentry, note: String(dlogentry) })
-      }
-    }
-
     log.info({ point: 'generate-end' })
 
     return { ok: true, name: 'sdkgen' }
@@ -482,19 +506,39 @@ function SdkGen(opts: SdkGenOptions) {
     const aopts = { path, errs }
     const src = fs.readFileSync(path, 'utf8')
 
-    const model = aontu.generate(src, aopts)
-
-    if (0 < errs.length) {
-      const serr = errs[0]
-      const err: any = new SdkGenError('Model Error: ' + serr.msg)
-      err.cause$ = [serr]
+    // AONTU THROWS; IT DOES NOT FILL `errs`.
+    //
+    // The `errs` array is handed to `generate` and stays empty on every
+    // failure — syntax, unresolved path and unify conflict alike all raise an
+    // AontuError instead (verified against 0.52 by running each). So the
+    // `0 < errs.length` branch this used to have could never fire, and every
+    // broken project model reached the CLI as a bare AontuError: `handleError`
+    // prints the raw object for anything that is not an SdkGenError, so the
+    // user got aontu's diagnostic followed by a stack trace into sdkgen's
+    // `dist/` and a dump of the error's own fields. It read as an sdkgen
+    // crash rather than a problem in their own file.
+    //
+    // The array is still passed, and still checked below, because that is
+    // aontu's documented option and a later version may start using it. Both
+    // routes build the error the same way, so they cannot drift.
+    let model: any
 
-      if ('syntax' === serr.why) {
-        err.uxmsg$ = true
+    try {
+      model = aontu.generate(src, aopts)
+    }
+    catch (aerr: any) {
+      if (true !== aerr?.aontu) {
+        throw aerr
       }
 
-      err.rooterrs$ = errs
-      throw err
+      // The structured errors are reachable after all — the thrown error
+      // carries the accessor the empty array was standing in for.
+      throw modelError(path, aerr,
+        'function' === typeof aerr.errs ? aerr.errs() : [])
+    }
+
+    if (0 < errs.length) {
+      throw modelError(path, errs[0], errs)
     }
 
     model.const = { name: model.name }
@@ -1039,9 +1083,14 @@ export {
   phpEntityAccessor,
   entityCacheField,
   isRbCoreConstant,
+  isRbSdkConstant,
   rbSafeTypeName,
   isSwiftSdkType,
   swiftSafeTypeName,
+  isPhpReservedType,
+  phpSafeTypeName,
+  isTsReservedType,
+  tsSafeTypeName,
   serverVariables,
   hasServerVariables,
   liveStrict,
@@ -1090,6 +1139,7 @@ export {
   repoInfo,
   apiName,
   langLabel,
+  originName,
   PUBLISHER,
   PUBLISHER_URL,
   SECURITY_EMAIL,