@voxgig/sdkgen 4.20.0 → 4.22.0

package/project/.sdk/src/cmp/ts/ReadmeQuick_ts.ts

@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -26,12 +21,8 @@ const ReadmeQuick = cmp(function ReadmeQuick(props: any) {
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
 
-  // Find the first published entity for examples
   const exampleEntity = Object.values(entity).find((e: any) => e.active !== false) as any
 
-  // Find a nested entity if available: one with a parent chain
-  // (relations.ancestors), an active load op, and a required non-id load
-  // param to demonstrate (the parent key, e.g. page_id).
   const nestedEntity = Object.values(entity).find((e: any) =>
     e.active !== false &&
     e.relations && e.relations.ancestors && 0 < e.relations.ancestors.length &&
@@ -71,13 +62,9 @@ const client = ${ctor}
 
   if (exampleEntity) {
     const eName = nom(exampleEntity, 'Name')
-    // Variable-safe lowercase name — a `Delete`/`Class` entity must not bind a
-    // reserved word (`const delete = ...` is a TS1109 syntax error).
     const eVar = exampleVarName(eName.toLowerCase(), 'ts')
     const article = /^[aeiou]/i.test(eName) ? 'an' : 'a'
     const opnames = entityOps(exampleEntity)
-    // Model-driven id key: `idF` is the entity's id-like MATCH field name, or
-    // null when it has none (then load/remove match on no argument).
     const idF = entityIdField(exampleEntity)
     // The id field on the RETURNED record's data type, or null. DISTINCT from
     // idF (the match key): an entity can key its load-match on an id it does not
@@ -109,9 +96,6 @@ for (const ${eVar} of ${eVar}s) {
       const neArticle = /^[aeiou]/i.test(neName) ? 'an' : 'a'
       const loadOp = nestedEntity.op && nestedEntity.op.load
 
-      // Model-driven match: every REQUIRED load-match key — the same shape
-      // that generates <Name>LoadMatch, so the example always type-checks.
-      // Parent keys (e.g. page_id) first, the entity's own id last.
       const neIdF = entityIdField(nestedEntity)
       const neRequired = opRequestShape(nestedEntity, 'load').items
         .filter((it: any) => !it.optional)
@@ -143,8 +127,6 @@ ${neMatchLines.join('\n')}
 `)
     }
     else if (opnames.includes('load')) {
-      // Every REQUIRED load-match key (id first) — the same shape that
-      // generates <Name>LoadMatch, so the example always type-checks.
       const loadRequired = opRequestShape(exampleEntity, 'load').items
         .filter((it: any) => !it.optional || it.name === idF)
         .sort((a: any, b: any) =>
@@ -177,21 +159,12 @@ try {
     // non-id fields and render a type-correct literal per field via
     // exampleValue — never a hardcoded field the entity may not have.
     if (opnames.includes('create') || opnames.includes('update') || opnames.includes('remove')) {
-      // Writable non-id example fields for an op body. For create the REQUIRED
-      // fields must all appear or the literal is not assignable to the typed
-      // <Name>CreateData (a TS2345); update is a patch, so a couple of fields
-      // suffice.
       const exampleFields = (opname: string): string[] => {
-        // ids are rendered separately as the match key for update/remove; a
-        // REQUIRED id stays (dropping it makes the literal unassignable).
         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)
-        // Required members must all appear or the literal is not assignable
-        // to the typed <Name>{Create,Update}Data; pad update (a patch) with a
-        // sample optional field or two.
         const chosen = 'create' === opname
           ? (required.length ? required : items.slice(0, 2))
           : required.concat(optional).slice(0, Math.max(2, required.length))
@@ -199,20 +172,10 @@ try {
           `  ${jsKey(it.name)}: ${exampleValue(exampleEntity, exampleEntity.op[opname], it.name, 'example_' + it.name)},`)
       }
 
-      // The id VALUE for an update/remove match. When the entity's DATA type
-      // carries the id (dataIdF) AND a `created` record exists, take it off the
-      // returned record; otherwise use a type-correct literal — reading
-      // `created.id` off an id-less data type is a TS2339.
-      // Type of the data field we would read off `created` (e.g. number for an
-      // integer id). null when unknown.
       const dataFields: any[] = exampleEntity.fields ? each(exampleEntity.fields) : []
       const dataIdType = dataIdF
         ? (dataFields.find((f: any) => f && f.name === dataIdF) || {}).type
         : null
-      // `created.<dataIdF>` is only usable as an op's id-match value when its
-      // type matches that op's id PARAM type. An id that is integer in the data
-      // type but string in the match path (a spec quirk seen on management
-      // APIs) would be a TS2322 otherwise — fall back to a type-correct literal.
       const usesCreatedId = (opname: string): boolean => {
         if (null == dataIdF || !opnames.includes('create')) {
           return false
@@ -222,8 +185,6 @@ try {
         const matchType = matchItem ? matchItem.type : null
         return null == matchType || null == dataIdType || matchType === dataIdType
       }
-      // `create` resolves to the ENTITY, so the id is reached through
-      // `.data()` — `created.id` is a TS2339 on the entity class.
       const idValueFor = (opname: string): string => usesCreatedId(opname)
         ? `created.data().${dataIdF}!`
         : exampleValue(exampleEntity, exampleEntity.op[opname], idF as string, 'example_id')
@@ -241,8 +202,6 @@ const created = await client.${eName}().create({${createBody}})
 `)
       }
       if (opnames.includes('update')) {
-        // Match on the id (from the returned `created` record when the data
-        // type carries one, else a literal), plus a couple of patch fields.
         const updateLines = (idF ? [`  ${idF}: ${idValueFor('update')},`] : []).concat(exampleFields('update'))
         const updateBody = updateLines.length ? '\n' + updateLines.join('\n') + '\n' : ''
         Content(`// Update${usesCreatedId('update') ? ' — the id comes off the returned entity\'s data()' : ''}
@@ -251,8 +210,6 @@ const updated = await client.${eName}().update({${updateBody}})
 `)
       }
       if (opnames.includes('remove')) {
-        // Every REQUIRED remove-match key: the id (off the created record
-        // when possible) plus parent keys like page_id.
         const removeLines = opRequestShape(exampleEntity, 'remove').items
           .filter((it: any) => !it.optional || it.name === idF)
           .sort((a: any, b: any) =>

package/project/.sdk/src/cmp/ts/ReadmeRef_ts.ts

@@ -1,5 +1,5 @@
 
-import { cmp, each, Content, canonToType, File, isAuthActive, isHttpBasicAuth, entityIdField, entityActions, opRequestShape, safeVarName, exampleVarName, jsKey, matchArg, idLiteral } from '@voxgig/sdkgen'
+import { cmp, each, Content, canonToType, File, isAuthActive, isHttpBasicAuth, entityIdField, entityActions, opRequestShape, safeVarName, exampleVarName, jsKey, matchArg, idLiteral, targetFeatures } from '@voxgig/sdkgen'
 import { ReadmeRefFeatures } from '@voxgig/sdkgen'
 
 import {
@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -55,7 +50,7 @@ const ReadmeRef = cmp(function ReadmeRef(props: any) {
   const { model } = props.ctx$
 
   const entity = getModelPath(model, `main.${KIT}.entity`)
-  const feature = getModelPath(model, `main.${KIT}.feature`)
+  const feature = targetFeatures(model, target)
 
   const publishedEntities = each(entity).filter((e: any) => e.active !== false)
 
@@ -196,7 +191,6 @@ Alias for \`${model.Name}SDK.test()\`.
       // Model-driven id key: null when this entity has no id-like field, in
       // which case load/remove match on no argument and update omits the id.
       const idF = entityIdField(ent)
-      // Variable-safe lowercase name (a `Delete` entity must not bind `delete`).
       const eVar = exampleVarName(ent.name, target.name)
 
       Content(`
@@ -266,15 +260,6 @@ const ${eVar} = client.${ent.Name}()
       }
 
 
-      // Custom actions.
-      //
-      // A POST route like `/api/planet/{id}/terraform` is folded into the
-      // `create` op as an alternative point, selected at call time by
-      // `$action`. The mechanism was implemented and documented NOWHERE — so
-      // for an API with two such routes, two of its six endpoints were
-      // unreachable by anyone reading the docs. A user who wanted `terraform`
-      // had to fall back to `direct()` and rebuild the URL by hand, which is
-      // exactly what the entity model exists to spare them.
       const actions = entityActions(ent)
       if (0 < actions.length) {
         Content(`### Actions
@@ -455,9 +440,6 @@ const client = new ${model.Name}SDK({
 \`\`\`
 
 `)
-      // The shared feature reference: options, defaults, usage and the
-      // considerations. Model facts, identical in every target, so they are
-      // written once in cmp/ReadmeRefFeatures.ts rather than here.
       ReadmeRefFeatures({ target })
     }
 

package/project/.sdk/src/cmp/ts/ReadmeTopQuick_ts.ts

@@ -10,11 +10,6 @@ import {
 import { exampleValue } from './utility_ts'
 
 
-// A `list()` on a NESTED entity needs its parent path params. The
-// quickstart used to emit `client.Moon().list()` for an entity at
-// `/planet/{planet_id}/moon`, which 404s against a live server from a
-// half-built URL — indistinguishable from "no such record". The model
-// already marks those params `reqd: true`; matchArg renders exactly them.
 function listMatchArg(ent: any): string {
   const idF = entityIdField(ent)
   return matchArg('ts', ent, 'list', idF, idLiteral(ent, 'list', idF))
@@ -87,9 +82,6 @@ for (const ${eVar} of ${eVar}s) {
       const neVar = exampleVarName(neName.toLowerCase(), 'ts')
       const loadOp = nestedEntity.op && nestedEntity.op.load
 
-      // Every REQUIRED load-match key (parent keys first, own id last) — the
-      // same shape that generates <Name>LoadMatch, so the example
-      // type-checks.
       const neIdF = entityIdField(nestedEntity)
       const neMatchLines = opRequestShape(nestedEntity, 'load').items
         .filter((it: any) => !it.optional || it.name === neIdF)
@@ -109,9 +101,6 @@ console.log(${neVar})
       hasCall = true
     }
 
-    // Fallback: APIs with only `load` (no list, no nested) — most public
-    // read-only services. Still show one concrete call. `load()` with no
-    // match is always valid (the match arg is optional).
     if (!hasCall && opnames.includes('load')) {
       Content(`// Load ${eName.toLowerCase()} data (returns a ${eName})
 const ${eVar} = await client.${eName}().load()

package/project/.sdk/src/cmp/ts/ReadmeTopTest_ts.ts

@@ -18,13 +18,6 @@ const ReadmeTopTest = cmp(function ReadmeTopTest(props: any) {
   // `load` on an op-less entity like Cloudsmith's `Abort`.
   const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
 
-  // The mock SEEDS NOTHING on its own.
-  //
-  // `SDK.test()` with no argument used to be shown alongside "populated with
-  // mock data" — and returned an empty array. The seed shape
-  // (`{ entity: { <name>: { <id>: {...} } } }`) was documented nowhere; the
-  // only way to find it was to read TestFeature.ts. Offline test mode is a
-  // headline feature of these SDKs, so its one worked example has to run.
   const seedEntity = exampleEntity ? nom(exampleEntity, 'name') : ''
   const seedFields = exampleEntity ?
     opRequestShape(exampleEntity, 'create').items
@@ -74,12 +67,16 @@ const client = ${model.const.Name}SDK.test({
             it.name === idF ? 'test01' : 'example_' + it.name)}`).join(', ')} }`
         : ''
     } else if ('create' === primaryOp || 'update' === primaryOp) {
+      const isIdField = (it: any) => it.name === idF || it.name === 'id'
       const items = opRequestShape(exampleEntity, primaryOp).items
-        .filter((it: any) => it.name !== idF && it.name !== 'id')
+        .filter((it: any) => !isIdField(it) || !it.optional)
       const required = items.filter((it: any) => !it.optional)
       const chosen = required.length ? required : items.slice(0, 3)
       arg = `{ ${chosen.map((it: any) =>
-        `${jsKey(it.name)}: ${exampleValue(exampleEntity, primaryOpDef, it.name, 'example_' + it.name)}`).join(', ')} }`
+        // A required id matches the record seeded into the mock above, so the
+        // example reads as one coherent story rather than two.
+        `${jsKey(it.name)}: ${exampleValue(exampleEntity, primaryOpDef, it.name,
+          isIdField(it) ? seedId : 'example_' + it.name)}`).join(', ')} }`
     }
     Content(`const ${eVar} = await client.${eName}().${primaryOp}(${arg})
 // ${eVar} is ${'list' === primaryOp ? `an array of ${eName} entities` : `the ${eName} entity`}, populated with mock data

package/project/.sdk/src/cmp/ts/Schema_ts.ts

@@ -12,27 +12,6 @@ import {
 } from '@voxgig/apidef'
 
 
-// THE GENERATED SCHEMA MODULE: the model's schemas, as data the SDK can run.
-//
-// Two exports, both struct.validate specs:
-//
-//   OPTSPEC     what makeOptions validates the caller's options against —
-//               the standard options from `main.kit.optspec` plus one entry
-//               per feature this target carries, built by helpers/optspec.
-//
-//   ENTITYSPEC  per entity, `{ data, op: { <opname> } }` — the record shape
-//               and each operation's request shape, mapped from the field
-//               type sentinels the model already carries (helpers/canonSpec).
-//               Emitted as an EMPTY MAP unless the `validate` feature is
-//               active, because nothing else reads it and every byte here is
-//               a byte in the consumer's package.
-//
-// A JSON OBJECT LITERAL, not a parsed string: JSON is a subset of the
-// language's own literal syntax, so the values land as data with no parse
-// step, and the backticks the sentinels carry (`\`$STRING\``) survive because
-// JSON.stringify quotes and escapes them. The config emitter has to choose
-// between a literal and a parsed blob because the config can be megabytes;
-// the spec is bounded by the model's field count, so it does not.
 const Schema = cmp(async function Schema(props: any) {
   const ctx$ = props.ctx$
   const target = props.target

package/project/.sdk/src/cmp/ts/TestDirect_ts.ts

@@ -24,6 +24,7 @@ import {
   jsOptProp, envName, envToken, liveStrict,
   jsKey,
   pointParts,
+  hasLiveScenarios,
 } from '@voxgig/sdkgen'
 
 
@@ -42,7 +43,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
   const ff = projectPath('src/cmp/ts/fragment/')
 
-  // Does a live run ASSERT, or merely observe? See helpers/testPolicy.
   const strict = liveStrict(model, target.name)
 
   const PROJECTNAME = envName(model)
@@ -59,16 +59,6 @@ const TestDirect = cmp(function TestDirect(props: any) {
       secret: env.${PROJECTNAME}_SECRET,` : ''}`
     : ''
 
-  // A templated server URL (OpenAPI server variables) makes a LIVE client
-  // impossible to construct without values: makeOptions raises rather than
-  // request a URL with a literal `{account_id}` in it. Taken from the
-  // environment, the same way the apikey is.
-  //
-  // Keys are quoted and the env read is bracketed via jsKey/jsProp: a server
-  // variable name is spec-derived and need not be a JS identifier — the URL
-  // grammar admits a leading digit ({2fa}), and a declared-but-unreferenced
-  // variable ({edge-zone}) is not constrained at all. Bare `name:` and
-  // `env.PROJ_SERVER_EDGE-ZONE` are both syntax errors.
   const svars = serverVariables(model)
   const serverEnvEntry = svars
     .map((v: any) => `\n    '${serverVarEnv(PROJECTNAME, v.name)}': ${JSON.stringify(v.dflt)},`).join('')
@@ -104,7 +94,7 @@ const TestDirect = cmp(function TestDirect(props: any) {
 
         Slot({ name: 'directSetup' }, () => {
           Content(`
-function liveScenariosActive() { return ${Object.values(model.main.kit.entity || {}).some((e: any) => Object.values(e.op || {}).some((o: any) => (o.points || []).some((p: any) => p.contract && JSON.parse(p.contract.json).live)))} && process.env.${PROJECTNAME}_TEST_LIVE === 'TRUE' }
+function liveScenariosActive() { return ${hasLiveScenarios(model)} && process.env.${PROJECTNAME}_TEST_LIVE === 'TRUE' }
 function directSetup(mockres?: any) {
   const calls: any[] = []
 
@@ -184,15 +174,6 @@ function unwrapListData(data: any): any[] | null {
 })
 
 
-// GraphQL-backed op: a REST-shaped direct() call (GET, params in the URL)
-// cannot reach it — every op, including list, synthesizes POST with the
-// query/variables as a JSON body, not URL params (see
-// MakeFetchDefUtility: spec.body only ever comes from an explicit `body`
-// field, never derived from `params`). apidef already built a real, valid
-// query or mutation document per point (point.graphql.doc, with variables
-// declared to match), so reuse that verbatim through the SDK's own
-// graphql() escape hatch instead of re-deriving a REST-shaped call that
-// cannot represent one.
 function generateDirectGraphql(
   opname: 'load' | 'list',
   entity: ModelEntity,
@@ -223,10 +204,6 @@ function generateDirectGraphql(
     ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
     : ''
 
-  // Asserted against the OUTGOING request body (what we sent), not the
-  // mocked response — response-shape correctness is the entity-level
-  // load/list tests' job; direct/graphql only has to prove the raw path
-  // reaches the endpoint with the right method and payload.
   const varAsserts = vars.map((_v: any, i: number) =>
     '      assert(calls[0].init.body.includes(\'direct0' + (i + 1) + '\'))\n').join('')
 
@@ -312,7 +289,6 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
       pathPlaceholders.add(part.slice(1, -1))
     }
   }
-  // Apply rename map (e.g. `androidId` -> `id` in parts).
   const renameMap = (loadPoint.rename?.param || {}) as Record<string, string>
   const renamedPlaceholders = new Set<string>()
   for (const ph of pathPlaceholders) {
@@ -337,20 +313,17 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     .map((q: any) => `      ${jsProp('query', q.name)} = ${JSON.stringify(q.example)}`)
     .join('\n')
 
-  // Get list info for live mode bootstrapping
   const listOp = entity.op?.list
   const listPoint = listOp?.points?.[0]
   const listParams = listPoint?.args?.params || []
   const listPath = listPoint ? normalizePathParams(pointParts(listPoint), listParams, listPoint.rename?.param) : ''
   const hasList = null != listPoint
 
-  // Ancestor params (not 'id') for live mode
   const ancestorParams = loadParams.filter((p: any) => p.name !== 'id')
 
   const paramAsserts = loadParams.map((p: any, i: number) =>
     '      assert(calls[0].url.includes(\'direct0' + (i + 1) + '\'))\n').join('')
 
-  // Build live list params
   const liveListParams = listParams.map((p: any) => {
     const key = p.name === 'id'
       ? entity.name + '01'
@@ -358,14 +331,11 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     return { name: p.name, key }
   })
 
-  // Build live ancestor params for load
   const liveAncestorParams = ancestorParams.map((p: any) => {
     const key = p.name.replace(/_id$/, '') + '01'
     return { name: p.name, key }
   })
 
-  // Prefix the live block with required-query setup so it applies to both
-  // the list-bootstrapped and the no-list cases.
   const liveQueryPrefix = liveQueryLines ? liveQueryLines + '\n' : ''
 
   // Path params with spec-provided examples — when present, prefer them
@@ -379,9 +349,6 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
   const allLoadParamsHaveExamples =
     loadParams.length > 0 && liveExampleParams.length === loadParams.length
 
-  // Set of idmap keys this test will read from in live mode. Used to emit
-  // a skip-on-missing-ids check so live runs without ENTID overrides skip
-  // gracefully instead of 4xx-ing on undefined params.
   let liveIdKeys: string[] = []
 
   let liveParamsBlock = ''
@@ -405,10 +372,6 @@ ${loadParams.map((p: any, i: number) => `      ${jsProp('params', p.name)} = 'di
       `        ${lp.name}: setup.idmap['${lp.key}'],`).join('\n')
     const ancestorParamLines = liveAncestorParams.map((lp: any) =>
       `      ${jsProp('params', lp.name)} = setup.idmap['${lp.key}']`).join('\n')
-    // Try every load-path param name as the candidate field on listData[0].
-    // Some APIs name the path param differently from the response field
-    // (e.g. path uses {id} while response has mal_id), so we attempt the
-    // exact name and skip the test cleanly when no candidate value exists.
     const idParamName = loadParams.find((p: any) => p.name === 'id')
       ? 'id'
       : (loadParams[0]?.name ?? 'id')
@@ -536,15 +499,12 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
   const listParams = listPoint.args?.params || []
   const listPath = normalizePathParams(pointParts(listPoint), listParams, listPoint.rename?.param)
 
-  // Required query params with spec-provided examples — needed to satisfy
-  // the API contract in live mode (see generateDirectLoad for rationale).
   const listQuery = listPoint.args?.query || []
   const liveQueryLines = listQuery
     .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
     .map((q: any) => `      ${jsProp('query', q.name)} = ${JSON.stringify(q.example)}`)
     .join('\n')
 
-  // Build live params
   const liveParams = listParams.map((p: any) => {
     const key = p.name === 'id'
       ? entity.name + '01'
@@ -579,8 +539,6 @@ ${mockLines}
 `
   }
 
-  // List path params come from idmap in live mode. Mark those keys so the
-  // test skips cleanly when the ENTID env var isn't set.
   const liveIdKeys: string[] = listParams.length > 0
     ? liveParams.map((lp: any) => lp.key)
     : []
@@ -588,7 +546,6 @@ ${mockLines}
     ? `    if (skipIfMissingIds(t, setup, ${JSON.stringify(liveIdKeys)})) return\n`
     : ''
 
-  // See generateDirectLoad: leniency is main.kit.test.live.strict.
   const offlineChecks = `      assert(result.ok === true)
       assert(result.status === 200)
       assert(null != result.data)
@@ -650,20 +607,12 @@ ${listChecks}
 }
 
 
-// Replace raw OpenAPI parameter names in path parts with model parameter names.
-// Path parts may have e.g. {subBreed} while model params use sub_breed.
-// When a rename mapping exists (e.g. closureId -> id), path parts contain the
-// renamed form {id} but params still use the original name closure_id.
-// The rename mapping is used to reverse-lookup the original param name.
 function normalizePathParams(
   parts: string[],
   params: any[],
   rename?: Record<string, string>
 ): string {
   return parts.map((part: string) => {
-    // Replace each {paramName} occurrence within the part.
-    // Handles both simple parts like "{id}" and compound parts like
-    // "{outputFields}.{format}" that contain multiple parameters.
     return part.replace(/\{([^}]+)\}/g, (match: string, rawName: string) => {
       const snaked = snakify(rawName)
       const depluralized = depluralize(snaked)

package/project/.sdk/src/cmp/ts/TestEntity_ts.ts

@@ -35,7 +35,8 @@ import {
   isHttpBasicAuth,
   entityDataIdField, envName, envToken,
   jsKey,
-  jsProp
+  jsProp,
+  hasLiveScenarios,
 } from '@voxgig/sdkgen'
 
 
@@ -44,10 +45,6 @@ import {
 } from './utility_ts'
 
 
-// GenCtx is the per-language generation context passed to every OpGen.
-// Languages with extra needs (Go's `gomodule`, PHP's `accessor`) extend
-// this shape locally. The signature `(ctx, step, index)` is now uniform
-// across all seven language tracks (Phase 1 of the templates refactor).
 type GenCtx = {
   model: Model
   entity: ModelEntity
@@ -79,16 +76,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
         secret: env.${PROJENVNAME}_SECRET,` : ''}`
     : ''
 
-  // A templated server URL (OpenAPI server variables) makes a LIVE client
-  // impossible to construct without values: makeOptions raises rather than
-  // request a URL with a literal `{account_id}` in it. So the live suite
-  // takes them from the environment the same way it takes the apikey.
-  //
-  // Keys are quoted and the env read is bracketed via jsKey/jsProp: a server
-  // variable name is spec-derived and need not be a JS identifier — the URL
-  // grammar admits a leading digit ({2fa}), and a declared-but-unreferenced
-  // variable ({edge-zone}) is not constrained at all. Bare `name:` and
-  // `env.PROJ_SERVER_EDGE-ZONE` are both syntax errors.
   const svars = serverVariables(model)
   const serverEnvEntry = svars
     .map((v: any) => `\n    '${serverVarEnv(PROJENVNAME, v.name)}': ${JSON.stringify(v.dflt)},`).join('')
@@ -98,7 +85,6 @@ const TestEntity = cmp(function TestEntity(props: any) {
           ${jsKey(v.name)}: ${jsProp('env', serverVarEnv(PROJENVNAME, v.name))},`).join('')}
         },`
 
-  // TODO: should be a utility function
   const ff = projectPath('src/cmp/ts/fragment/')
 
   Folder({ name: entity.name }, () => {
@@ -242,7 +228,7 @@ function basicSetup(extra?: any) {
       if (!live && maybeSkipControl(t, 'entityOp', '${entity.name}.' + op, live)) return
     }
 
-    ${Object.values(model.main.kit.entity || {}).some((e: any) => Object.values(e.op || {}).some((o: any) => (o.points || []).some((p: any) => p.contract && JSON.parse(p.contract.json).live))) ? `if (live) { t.skip('Covered by live operation scenarios'); return }` : ''}
+    ${hasLiveScenarios(model) ? `if (live) { t.skip('Covered by live operation scenarios'); return }` : ''}
     const setup = basicSetup()
     if (setup.live) {
       return runLiveEntity(setup, ${JSON.stringify(entity)}, ${JSON.stringify(basicflow)}, '${nom(entity, 'Name')}')
@@ -381,12 +367,6 @@ const generateList: OpGen = (ctx, step, index) => {
     const hasRefData = validRef && allSteps.some(s => 'create' === s.op &&
       ((s.input.ref ?? entity.name + '_ref01') === validRef))
 
-    // Guard on a DATA id field (entityDataIdField), NOT entity.id (the load-MATCH
-    // key): an entity can have a match id in its path while its RESPONSE record
-    // has no `id` field (e.g. Multichannel's Template — data fields meta/status/…,
-    // no id). Then `${validRef}_data.id` is undefined and select(list, { id:
-    // undefined }) spuriously matches id-less records, so ItemExists/ItemNotExists
-    // are meaningless. Emit them only when `.id` is a real data field.
     if ('ItemExists' === validator.apply && hasRefData && hasDataId) {
       Content(`
     assert(!isempty(select(${listvar}, { id: ${validRef}_data.id })))
@@ -502,14 +482,6 @@ const generateLoad: OpGen = (ctx, step, index) => {
 
   const hasEntId = null != entity.id
 
-  // When the entity has no id model field but the load operation requires
-  // path parameters (e.g. cotizacion needs {casa}/{fecha}), calling
-  // load({}) leaves the URL with literal {param} placeholders and the live
-  // API returns 404 HTML, which the SDK then fails to parse as JSON. There
-  // is no synthetic identifier to substitute, so skip emitting the load
-  // step's call in that case — but still declare the entity-var if no
-  // prior step has, so that later flow steps (e.g. remove) referencing
-  // ${entvar} compile.
   const loadOp = entity.op?.load
   const loadPoint = loadOp?.points?.[0]
   const loadPathParams = loadPoint?.args?.params || []

package/project/.sdk/src/cmp/ts/TestLive_ts.ts

@@ -1,4 +1,4 @@
-import { cmp, File, Content, entityCollection, envName, serverVariables, serverVarEnv } from '@voxgig/sdkgen'
+import { cmp, File, Content, entityCollection, envName, serverVariables, serverVarEnv, liveHint, pointFacts } from '@voxgig/sdkgen'
 import { nom } from '@voxgig/apidef'
 
 const TestLive = cmp(function TestLive(props: any) {
@@ -8,11 +8,17 @@ const TestLive = cmp(function TestLive(props: any) {
     if (entity.active === false) continue
     for (const [op, operation] of Object.entries(entity.op || {}) as any[]) {
       for (const point of operation.points || []) {
-        const facts = point.contract ? JSON.parse(point.contract.json) : {}
-        if (model.main.kit.info?.auth === false) facts.security = []
+        // Only what the runner reads, not the whole point.
+        const all: any = pointFacts(props.ctx$, point)
+        const facts: any = {
+          live: liveHint(point),
+          security: model.main.kit.info?.auth === false ? [] : all.security,
+          securitySource: all.securitySource,
+          responses: all.responses,
+        }
         const same = operation.points.filter((p: any) => JSON.stringify(p.select || {}) === JSON.stringify(point.select || {}))
         plan.push({ entity: entity.name, accessor: nom(entity, 'Name'), op,
-          id: point.contract?.id || point.method + ' ' + point.orig, contractVersion: point.contract?.version, kind: point.kind, graphql: point.graphql, path: point.orig, method: point.method,
+          id: point.method + ' ' + point.orig, contractVersion: 1, kind: point.kind, graphql: point.graphql, path: point.orig, method: point.method,
           action: point.select?.$action, rename: point.rename, args: point.args, facts, reachable: same.length === 1 })
       }
     }

package/project/.sdk/src/cmp/ts/Test_ts.ts

@@ -7,8 +7,6 @@ import { cmp, each, Folder, entityCollection,
   TestControl } from '@voxgig/sdkgen'
 
 
-// import { Quick } from './Quick_ts'
-// import { TestMain } from './TestMain_ts'
 import { TestLive } from './TestLive_ts'
 import { TestDirect } from './TestDirect_ts'
 import { TestEntity } from './TestEntity_ts'
@@ -25,8 +23,6 @@ const Test = cmp(function Test(props: any) {
     // Write-once: a project's edited control file survives regeneration.
     TestControl({ target, dir: 'test' })
     TestLive({ target })
-    // Quick({ target })
-    // TestMain({ target })
 
     ReadmeExampleTest({ target })
     ReadmeExamplesTest({ target })

package/project/.sdk/src/cmp/ts/fragment/Config.data.fragment.ts

@@ -8,31 +8,11 @@ const FEATURE_CLASS: Record<string, typeof BaseFeature> = {
 }
 
 
-// Per-feature plugin DEFINITIONS (voxgig/plugin `Definition` values), from
-// the model's active plugin groups. A feature that takes a `plugins` option
-// (secrets over sekreto) reads its own entry; a feature with no plugins has
-// none. Named imports above make each definition statically reachable, so
-// an SDK carries exactly the plugin modules its model selects — the same
-// leanness the old side-effect registry imports bought, without a registry.
 const FEATURE_PLUGINS: Record<string, any[]> = {
   // #FeaturePlugins
 }
 
 
-// THE API MODEL, EMBEDDED AS DATA (sdkgen rung L1).
-//
-// The literal form of this file declares the whole model as nested object
-// literals on the class. For a large API that is megabytes of source that the
-// TypeScript compiler must parse and infer a type for on every build, and that
-// the JavaScript engine must build node by node on every module load.
-//
-// As a single string constant it is one token to the compiler, and V8's JSON
-// parser builds the object far faster than the equivalent literal - JSON.parse
-// is the well-worn trick for exactly this shape of data.
-//
-// Emitted only above a size threshold, or when `main.kit.config.repr` pins it:
-// for a small model the literal is smaller, loads no slower, and is far easier
-// to read when debugging.
 const CONFIG_DATA = 'CONFIGJSON'
 
 
@@ -41,7 +21,6 @@ class Config {
   makeFeature(this: any, fn: string) {
     const fc = FEATURE_CLASS[fn]
     const fi = new fc()
-    // TODO: errors etc
     return fi
   }
 
@@ -55,12 +34,6 @@ class Config {
 }
 
 
-// Parsed ONCE, at module load, exactly like the literal form was built once.
-//
-// The parsed data is assigned onto an instance rather than replacing it, so
-// `config.main` / `.feature` / `.options` / `.entity` read exactly as they did
-// when they were field initialisers, and `makeFeature` stays where it was on
-// the prototype. Callers cannot tell which representation they were given.
 const config: any = Object.assign(new Config(), JSON.parse(CONFIG_DATA))
 
 export {