@voxgig/sdkgen 1.3.17 → 1.3.18

package/src/helpers/collectDeps.ts

@@ -27,21 +27,53 @@ function collectDeps(
   model: SdkModel,
   targetName: string,
   targetDeps: Record<string, ModelDep> | undefined,
+  log?: any,
 ): DepEntry[] {
   const out: DepEntry[] = []
   const feature = getModelPath(model, `main.${KIT}.feature`)
 
+  // Deduplicate by package name. Two features can require the same package
+  // (or a feature and the target itself can), and every Package_<lang>.ts
+  // renders one manifest line per entry — a duplicate key is a hard parse
+  // error in go.mod and Cargo.toml, and silently last-wins in package.json.
+  // FIRST occurrence wins, so the deterministic (sorted-key) feature order
+  // decides; a conflicting version is reported rather than silently dropped.
+  const seen: Record<string, DepEntry> = {}
+
+  const add = (dep: any, source: 'feature' | 'target', owner: string) => {
+    const name = dep.key$
+    if (null == name) return
+
+    const prev = seen[name]
+    if (null != prev) {
+      if (log?.warn && prev.version !== dep.version) {
+        log.warn({
+          point: 'dep-version-conflict', target: targetName, dep: name,
+          kept: prev.version, dropped: dep.version, from: owner,
+          note: `${targetName}: dependency ${name} declared twice with ` +
+            `different versions — keeping ${prev.version} (${prev.source}), ` +
+            `ignoring ${dep.version} (${source} ${owner})`,
+        })
+      }
+      return
+    }
+
+    const entry: DepEntry = {
+      name,
+      version: dep.version,
+      source,
+      raw: dep,
+    }
+    seen[name] = entry
+    out.push(entry)
+  }
+
   each(feature, (f: any) => {
     const langDeps = f?.deps?.[targetName]
     if (!langDeps) return
     each(langDeps, (dep: any) => {
       if (dep?.active) {
-        out.push({
-          name: dep.key$,
-          version: dep.version,
-          source: 'feature',
-          raw: dep,
-        })
+        add(dep, 'feature', f.name)
       }
     })
   })
@@ -49,12 +81,7 @@ function collectDeps(
   if (targetDeps) {
     each(targetDeps, (dep: any) => {
       if (dep?.active !== false) {
-        out.push({
-          name: dep.key$,
-          version: dep.version,
-          source: 'target',
-          raw: dep,
-        })
+        add(dep, 'target', targetName)
       }
     })
   }

package/src/helpers/naming.ts

@@ -69,6 +69,63 @@ const RESERVED: Record<string, Set<string>> = {
 }
 
 
+// Ruby CORE CONSTANTS — a different hazard from the keyword sets above.
+//
+// The keyword sets guard local-variable BINDINGS. This set guards generated
+// top-level CONSTANTS. Ruby constants share one namespace with the core
+// classes, and reassigning one is not an error — it silently replaces it:
+//
+//   File = Struct.new(:name)     # ::File is now a Struct
+//   File.join('a', 'b')          # NoMethodError — every later caller breaks
+//
+// The typed model emits `<Name> = Struct.new(...)` per entity, so an API with
+// a `/files` collection (entity `File`) used to clobber Ruby's File class and
+// take the whole SDK down with it — the generated test runner calls
+// `File.join` to locate `.env.local`, so `rb` failed at require time.
+//
+// Only names Ruby itself defines at top level are listed: reassigning any of
+// them breaks working code somewhere. Names that merely LOOK builtin but are
+// not core constants (e.g. `Response`, `Record`) are safe and stay untouched,
+// which keeps the rename off every SDK that does not actually collide.
+const RB_CORE_CONSTANTS = new Set<string>([
+  // classes an entity name plausibly lands on
+  'Array', 'Binding', 'Class', 'Comparable', 'Complex', 'Data', 'Dir',
+  'Encoding', 'Enumerator', 'Exception', 'Fiber', 'File', 'Float', 'Hash',
+  'IO', 'Integer', 'Method', 'Module', 'Mutex', 'Numeric', 'Object', 'Proc',
+  'Queue', 'Random', 'Range', 'Rational', 'Regexp', 'Set', 'Signal', 'String',
+  'Struct', 'Symbol', 'Thread', 'Time', 'UnboundMethod',
+  // modules / singletons
+  'Enumerable', 'GC', 'Kernel', 'Marshal', 'Math', 'ObjectSpace', 'Process',
+  'Warning',
+  // the rest of the exception hierarchy an API might name an entity after
+  'ArgumentError', 'IndexError', 'IOError', 'KeyError', 'NameError',
+  'NotImplementedError', 'RangeError', 'RuntimeError', 'StandardError',
+  'StopIteration', 'SystemExit', 'TypeError', 'ZeroDivisionError',
+  // literal singletons
+  'FalseClass', 'NilClass', 'TrueClass',
+])
+
+
+// Is `Name` a constant Ruby already defines at top level?
+function isRbCoreConstant(Name: string): boolean {
+  return RB_CORE_CONSTANTS.has(Name)
+}
+
+
+// A top-level-safe Ruby constant name for a generated type: the name
+// unchanged, unless Ruby core already owns it, in which case `Type` is
+// appended (`File` -> `FileType`). Applied ONLY to the bare entity data type
+// — the per-op type names always carry a suffix (`FileCreateData`,
+// `FileLoadMatch`), which no core constant matches.
+//
+// The entity ACCESSOR keeps its original name (`client.File(...)`): methods
+// and constants live in separate namespaces in Ruby, so the accessor never
+// collided and the public surface is unchanged.
+function rbSafeTypeName(Name: string): string {
+  return isRbCoreConstant(Name) ? Name + 'Type' : Name
+}
+
+
 // Is `name` a reserved word (an illegal identifier) in the target language?
 function isReservedName(name: string, lang: string): boolean {
   const set = RESERVED[lang]
@@ -130,6 +187,8 @@ export {
   isReservedName,
   safeVarName,
   exampleVarName,
+  isRbCoreConstant,
+  rbSafeTypeName,
   jsProp,
   jsOptProp,
   jsKey,

package/src/helpers/opShape.ts

@@ -26,7 +26,60 @@
 // flag) and render them in the target language's struct/interface/TypedDict
 // syntax; the policy itself is language-neutral and tested in isolation.
 
-import { each } from 'jostraca'
+import { each, names } from 'jostraca'
+import { KIT, getModelPath } from '@voxgig/apidef'
+
+
+// THE entity collection for a model — resolved once, with a stable identity.
+//
+// Two problems this solves, both caused by every component calling
+// `getModelPath(model, 'main.<KIT>.entity')` for itself:
+//
+//   * CORRECTNESS. getModelPath drops `active: false` entries by default, but
+//     the consumer scaffold (create-sdkgen Root.ts) generates entity code for
+//     EVERY entity and every EntityTypes_<lang> emits data types with
+//     `only_active: false`. Class-name assignment done against the filtered
+//     view cannot see the inactive entities whose data types it must avoid.
+//     This resolver always returns the unfiltered collection.
+//
+//   * PERFORMANCE. getModelPath REBUILDS the container object on every call
+//     when filtering, so the WeakMap memos below never hit across callers —
+//     the O(n·ops) class-name assignment re-ran per entity per target. At 500
+//     entities x 22 targets that was ~15s of pure recomputation; caching the
+//     resolved collection on the model makes it ~3ms.
+const _entityCollCache = new WeakMap<object, any>()
+
+function entityCollection(model: any): any {
+  if (null == model || 'object' !== typeof model) {
+    return {}
+  }
+  const cached = _entityCollCache.get(model)
+  if (null != cached) {
+    return cached
+  }
+  const coll = getModelPath(model, `main.${KIT}.entity`,
+    { only_active: false, required: false }) || {}
+  deriveEntityNames(coll)
+  _entityCollCache.set(model, coll)
+  return coll
+}
+
+
+// Derive the PascalCase `Name` on every entity in a collection.
+//
+// `Name` is injected LAZILY by jostraca's names(), historically by whichever
+// component happened to run first (create-sdkgen Root.ts, or an EntityTypes
+// emitter). Anything reading `e.Name` before that ran saw `undefined` — and
+// because the helpers below MEMOISE, one early read poisoned the result for
+// the whole run (`undefinedEntity` class names; a permanently empty collision
+// list). The helpers therefore derive `Name` themselves, up front, so they
+// never depend on component ordering. Idempotent: names() is only called for
+// an entity that lacks `Name`.
+function deriveEntityNames(entityColl: any): any[] {
+  const ents = each(entityColl).filter((e: any) => e && null != e.name)
+  ents.forEach((e: any) => { if (null == e.Name) names(e, e.name) })
+  return ents
+}
 
 
 // The five ops, and whether their request payload is a `Match` (query/id) or
@@ -156,8 +209,21 @@ function opRequestShape(ent: any, opname: string):
     return { items: [], fromParams: false }
   }
 
+  // Ops that carry a BODY are the exception to "op-declared params win":
+  // their request payload is BOTH. `PUT /v1/todo/item/{id}` declares the path
+  // param `id`, which the SDK resolves out of reqdata (see the param
+  // utility's reqmatch -> match -> reqdata search), while the fields the
+  // caller wants to change come from the entity. Params alone produced
+  // `<Name>UpdateData = { id }` — no way to send anything to update.
+  //
+  // The param stays in the payload because the path needs it; keeping it out
+  // of the request BODY is the model's job, via the op's `transform.req`
+  // (@voxgig/apidef restricts the body to a closed request schema's declared
+  // properties).
+  const isbodyop = 'create' === opname || 'update' === opname || 'patch' === opname
+
   const params = opParams(op)
-  if (0 < params.length) {
+  if (0 < params.length && !isbodyop) {
     const items = params.map((p: any) => ({
       name: p.name,
       type: p.type,
@@ -166,15 +232,25 @@ function opRequestShape(ent: any, opname: string):
     return { items, fromParams: true }
   }
 
+  const paramItems = isbodyop ? params.map((p: any) => ({
+    name: p.name,
+    type: p.type,
+    optional: false === p.reqd,
+  })) : []
+  const paramNames = new Set(paramItems.map((p: any) => p.name))
+
   const fields = (ent.fields ? each(ent.fields) : [])
     .filter((f: any) => f.active !== false)
     .filter((f: any) => fieldInOp(f, opname))
 
-  const items = fields.map((f: any) => ({
-    name: f.name,
-    type: f.type,
-    optional: fieldOptional(f, opname),
-  }))
+  const items = paramItems.concat(
+    fields
+      .filter((f: any) => !paramNames.has(f.name))
+      .map((f: any) => ({
+        name: f.name,
+        type: f.type,
+        optional: fieldOptional(f, opname),
+      })))
 
   return { items, fromParams: false }
 }
@@ -250,6 +326,16 @@ function entityPrimaryOp(ent: any): string | null {
 // … The DATA type keeps its canonical `<Name>` — only the suffixed class
 // yields. Deterministic (sorted-key iteration) and stable across runs.
 //
+// Covers EVERY entity, active or not: the consumer scaffold (create-sdkgen
+// Root.ts) iterates the RAW entity collection, and every EntityTypes_<lang>
+// emits with `only_active: false`, so an inactive entity still contributes a
+// generated data type AND still needs a class name. Filtering to actives here
+// left inactive entities on the un-deduped `<Name>Entity` fallback and left
+// their data types out of `taken` — so an ACTIVE entity's class could collide
+// with an INACTIVE entity's emitted data type (e.g. active `project` ->
+// class `ProjectEntity` vs inactive `project-entity` -> type `ProjectEntity`,
+// a redeclaration in Go).
+//
 // Memoised per entity-collection object so the O(n) assignment runs once.
 const _classNameCache = new WeakMap<object, Record<string, string>>()
 
@@ -259,7 +345,7 @@ function entityClassNames(entityColl: any): Record<string, string> {
     return cached
   }
 
-  const ents = each(entityColl).filter((e: any) => e && e.active !== false)
+  const ents = deriveEntityNames(entityColl)
 
   // 1. Every top-level DATA-type name the target emits.
   const taken: Record<string, boolean> = {}
@@ -314,8 +400,8 @@ function entityClassName(ent: any, entityColl: any): string {
 // merging in ts. The names cannot be auto-renamed here — the generated
 // entity classes and op fragments reference them by token — so the guard
 // surfaces the collision loudly instead. Returns the sorted duplicate names
-// (empty when clean). Callers must have derived `Name` on each entity
-// (every EntityTypes emitter does).
+// (empty when clean). `Name` is derived here (deriveEntityNames), so the
+// guard cannot be silently disabled by running before an emitter.
 //
 // Memoised per entity-collection object, like entityClassNames.
 const _typeCollisionCache = new WeakMap<object, string[]>()
@@ -329,8 +415,7 @@ function entityTypeCollisions(entityColl: any): string[] {
   const counts: Record<string, number> = {}
   const bump = (n: string) => { counts[n] = (counts[n] || 0) + 1 }
 
-  each(entityColl)
-    .filter((e: any) => e && null != e.name && null != e.Name)
+  deriveEntityNames(entityColl)
     .forEach((e: any) => {
       bump(e.Name)
       for (const op of ['load', 'list', 'create', 'update', 'remove']) {
@@ -444,6 +529,8 @@ function entityDataIdField(ent: any): string | null {
 
 export {
   OP_SUFFIX,
+  deriveEntityNames,
+  entityCollection,
   opTypeName,
   opParams,
   opRequestShape,

package/src/sdkgen.ts

@@ -5,7 +5,7 @@ import Path from 'node:path'
 
 import { prettyPino, Pino } from '@voxgig/util'
 
-import { Jsonic } from 'jsonic'
+import { Jsonic } from '@tabnas/jsonic'
 import * as JostracaModule from 'jostraca'
 import { Aontu } from 'aontu'
 
@@ -51,8 +51,8 @@ import { getMatchEntries } from './helpers/getMatchEntries'
 import { collectDeps } from './helpers/collectDeps'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonKey } from './helpers/canonType'
-import { OP_SUFFIX, opTypeName, opParams, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions } from './helpers/opShape'
-import { isReservedName, safeVarName, exampleVarName, jsProp, jsOptProp, jsKey } from './helpers/naming'
+import { OP_SUFFIX, opTypeName, opParams, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
+import { isReservedName, safeVarName, exampleVarName, isRbCoreConstant, rbSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
 import {
   packageName,
   installCommand,
@@ -473,9 +473,13 @@ export {
   entityClassName,
   entityTypeCollisions,
   warnEntityTypeCollisions,
+  deriveEntityNames,
+  entityCollection,
   isReservedName,
   safeVarName,
   exampleVarName,
+  isRbCoreConstant,
+  rbSafeTypeName,
   jsProp,
   jsOptProp,
   jsKey,