@voxgig/sdkgen 3.7.2 → 3.7.3

package/project/.sdk/src/cmp/seneca-provider/Extras_seneca-provider.ts

@@ -242,8 +242,15 @@ function seedRecord(e: any, idx: number): Record<string, any> {
     else if (e.parents.includes(f.name)) {
       // A nested entity's parent id must match a record the parent seeds, or
       // the offline store answers nothing and every nested test reads as a
-      // false pass.
-      out[f.name] = `${f.parentEntity}0`
+      // false pass. Reuses parentSeed's fallback rather than f.parentEntity
+      // directly: when no entity in the model shares this key's name (the
+      // common case for a scoping param like `user_id` with no `user`
+      // entity, or a same-named response field that means something else
+      // entirely, like GitHub's `owner`), f.parentEntity is '' and seeding
+      // '0' desynced the record from every query built against the SAME
+      // key via parentSeed (parentPairs, crudTest, ...) — 0 results, or a
+      // seeded field asserted against the wrong literal.
+      out[f.name] = parentSeed(e, f.name)
     }
     else if ('number' === f.kind) {
       out[f.name] = 100 * (idx + 1)
@@ -407,11 +414,20 @@ describe('${provider.fileBase}', () => {
 
 `)
 
-      if (subject.cmds.includes('list')) {
-        Content(`
-  it('${subject.name}-list', async () => {
+      // Every flat entity (no parent keys), not just one "subject" — a
+      // provider with two or more flat siblings used to leave every one
+      // but the busiest untested beyond the accessor check above. A bare
+      // `list$()`/`load$(id)` call has no way to carry a parent key, so
+      // entities that need one are covered by the `nested` block below
+      // instead, with their keys filled in.
+      const flat = provider.entities.filter((e: any) => 0 === e.parents.length)
+
+      each(flat, (e: any) => {
+        if (e.cmds.includes('list')) {
+          Content(`
+  it('${e.name}-list', async () => {
     const seneca = await makeSeneca()
-    const list = await seneca.entity('provider/${provider.lower}/${subject.name}').list$()
+    const list = await seneca.entity('provider/${provider.lower}/${e.name}').list$()
 
     assert.equal(list.length, 2)
 
@@ -420,25 +436,25 @@ describe('${provider.fileBase}', () => {
     // survive into the Seneca entity.
     assert.equal(
       list[0].canon$({ string: true }),
-      'provider/${provider.lower}/${subject.name}',
+      'provider/${provider.lower}/${e.name}',
     )
   })
 
 `)
-      }
+        }
 
-      if (subject.cmds.includes('load')) {
-        Content(`
-  it('${subject.name}-load', async () => {
+        if (e.cmds.includes('load')) {
+          Content(`
+  it('${e.name}-load', async () => {
     const seneca = await makeSeneca()
     const found = await seneca
-      .entity('provider/${provider.lower}/${subject.name}')
-      .load$('${subject.name}0')
+      .entity('provider/${provider.lower}/${e.name}')
+      .load$('${e.name}0')
 
-    assert.equal(found.${subject.idf || 'id'}, '${subject.name}0')
+    assert.equal(found.${e.idf || 'id'}, '${e.name}0')
     assert.equal(
       found.canon$({ string: true }),
-      'provider/${provider.lower}/${subject.name}',
+      'provider/${provider.lower}/${e.name}',
     )
   })
 
@@ -446,17 +462,18 @@ describe('${provider.fileBase}', () => {
   // A 404 from a single-item read is an ordinary "not found" answer, not a
   // failure: the provider turns it into null rather than letting the SDK
   // throw.
-  it('${subject.name}-load-missing', async () => {
+  it('${e.name}-load-missing', async () => {
     const seneca = await makeSeneca()
     const missing = await seneca
-      .entity('provider/${provider.lower}/${subject.name}')
-      .load$('nosuch${subject.name}')
+      .entity('provider/${provider.lower}/${e.name}')
+      .load$('nosuch${e.name}')
 
     assert.equal(missing, null)
   })
 
 `)
-      }
+        }
+      })
 
       // A nested entity cannot build its path without the parent id. That is
       // the mistake this target exists to make impossible, so pin it.
@@ -469,17 +486,31 @@ describe('${provider.fileBase}', () => {
         const pairs = e.parents
           .map((k: string) => `${k}: '${parentSeed(e, k)}'`).join(', ')
 
-        Content(`
+        // The guard is PER OP (Main's opParents), not a blanket property of
+        // the entity, so the op this test calls has to be one that actually
+        // requires `key` — hardcoding `list` assumed every nested entity's
+        // list is parent-scoped, which fails for e.g. an entity guarded on
+        // load/update/remove but whose list is unscoped (GitHub's `repo`:
+        // owner guards load, not list).
+        const guardOp = ['list', 'load', 'update', 'remove']
+          .find((op: string) => (e.opParents[op] || []).includes(key))
+
+        if (null != guardOp) {
+          const call = 'list' === guardOp ?
+            `${guardOp}$({})` : `${guardOp}$({ id: '${e.name}0' })`
+
+          Content(`
   it('${e.name}-needs-${key}', async () => {
     const seneca = await makeSeneca()
 
     await assert.rejects(
-      () => seneca.entity('provider/${provider.lower}/${e.name}').list$({}),
+      () => seneca.entity('provider/${provider.lower}/${e.name}').${call},
       /${key} is required/,
     )
   })
 
 `)
+        }
         if (e.cmds.includes('list')) {
           // Assert on the SEEDED RECORDS, not merely that an array came back.
           // `Array.isArray` is true of the empty array, so the nested-list
@@ -4024,4 +4055,6 @@ export {
   Workflow,
   Readme,
   Docs,
+  seedRecord,
+  parentSeed,
 }

package/project/.sdk/src/cmp/seneca-provider/Main_seneca-provider.ts

@@ -2,7 +2,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder,
   entityCollection, entityOps, entityIdField, entityClassName,
-  opRequestShape, opParams, entityPath,
+  opRequestShape, opParams, ownPoint, entityPath,
   collectDeps, repoInfo, packageName, packageVersion, apiName, envName,
   authorInfo, contributorList, isAuthActive, jsKey, jsProp,
   SdkGenError,
@@ -74,12 +74,19 @@ function requiredKeys(ent: any, opname: string): string[] {
 // `<entity>_id` path param to `id` besides, which is why most APIs never reach
 // the fallback.
 //
-// When it does NOT answer, the record key is the LAST required path param of a
-// single-item op: a route addresses parents first and the record last, by
-// construction. Without this the key was simply unknown, so a param named
-// `code` failed the `!== idf` test in opParentKeys and was classified as a
-// PARENT — `load$('SAVE20')` threw "coupon load: code is required" instead of
-// loading anything, and the entity was treated as nested throughout.
+// When it does NOT answer, the record key is the LAST path param of the
+// op's own point, in PATH order — a route addresses parents first and the
+// record last, by construction. Without this the key was simply unknown,
+// so a param named `code` failed the `!== idf` test in opParentKeys and
+// was classified as a PARENT — `load$('SAVE20')` threw "coupon load: code
+// is required" instead of loading anything, and the entity was treated as
+// nested throughout.
+//
+// opParams(op) is NOT the source here: it alphabetizes params for output
+// stability, which loses path order on a 3+-param route — Airtable's
+// record (base_id, table_id, record_id) alphabetizes with table_id last,
+// so the old `params[params.length - 1]` picked the wrong parent as the
+// record's own key. The point's own `parts` still has the true order.
 function recordKey(ent: any): string {
   const idf = entityIdField(ent)
   if (null != idf && '' !== idf) {
@@ -88,13 +95,18 @@ function recordKey(ent: any): string {
 
   for (const opname of ['load', 'remove', 'update']) {
     const op = (ent.op || {})[opname]
-    if (null == op) {
+    if (null == op || 0 === (op.points || []).length) {
       continue
     }
 
-    const params = opParams(op).filter((p: any) => false !== p.reqd)
-    if (0 < params.length) {
-      return String((params[params.length - 1] as any).name)
+    const canonical = op.points.filter((pt: any) =>
+      null == (pt && pt.select && pt.select['$action']))
+    const point = ownPoint(0 < canonical.length ? canonical : op.points)
+    const parts: string[] = (point && point.parts) || []
+    const lastParam = [...parts].reverse().find((p: string) => p.startsWith('{'))
+
+    if (null != lastParam) {
+      return lastParam.slice(1, -1)
     }
   }
 
@@ -966,4 +978,5 @@ if ('undefined' !== typeof module) {
 
 export {
   Main,
+  recordKey,
 }

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

@@ -153,6 +153,92 @@ 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,
+  point: any,
+  strict: boolean,
+) {
+  const doc: string = point.graphql.doc
+  const vars: any[] = point.graphql.vars || []
+
+  const varLine = (target: string, key: string, v: any) =>
+    `      ${target}[${JSON.stringify(v.name)}] = ${key}`
+
+  const mockVarLines = vars.map((v: any, i: number) =>
+    varLine('variables', `'direct0${i + 1}'`, v)).join('\n')
+
+  const liveVarLines = vars.map((v: any) => {
+    const from = v.from || v.name
+    const key = ('id' === from ? entity.name : from.replace(/_id$/, '')) + '01'
+    return varLine('variables', `setup.idmap['${key}']`, v)
+  }).join('\n')
+
+  const liveIdKeys = vars.map((v: any) => {
+    const from = v.from || v.name
+    return ('id' === from ? entity.name : from.replace(/_id$/, '')) + '01'
+  })
+
+  const skipMissingLine = 0 < liveIdKeys.length
+    ? `    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('')
+
+  const offlineChecks = `      assert(result.ok === true)
+      assert(result.status === 200)
+      assert(null != result.data)
+      assert(calls.length === 1)
+      assert(calls[0].init.method === 'POST')
+${varAsserts}`
+
+  const checks = strict ?
+    offlineChecks.replace(/^ {6}/gm, '    ').replace(/^ {4}$/gm, '') :
+    `    if (setup.live) {
+      // Live mode is lenient: synthetic ids frequently fail server-side
+      // validation. Skip rather than fail when the call doesn't come back
+      // clean.
+      if (!result.ok || result.status < 200 || result.status >= 300) {
+        return
+      }
+    } else {
+${offlineChecks}    }`
+
+  Content(`
+  test('direct-${opname}-${entity.name}', async (t: any) => {
+    const setup = directSetup()
+    if (maybeSkipControl(t, 'direct', 'direct-${opname}-${entity.name}', setup.live)) return
+${skipMissingLine}    const { client, calls } = setup
+
+    const variables: any = {}
+    if (setup.live) {
+${liveVarLines || '      // no variables'}
+    } else {
+${mockVarLines || '      // no variables'}
+    }
+
+    const result: any = await client.graphql(${JSON.stringify(doc)}, variables)
+
+${checks}
+  })
+`)
+}
+
+
 function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean) {
   const loadOp = entity.op?.load
   const loadPoint: ModelPoint | undefined = loadOp?.points?.[0]
@@ -161,6 +247,11 @@ function generateDirectLoad(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
+  if ('graphql' === (loadPoint as any).kind) {
+    generateDirectGraphql('load', entity, loadPoint, strict)
+    return
+  }
+
   const allLoadParams = loadPoint.args?.params || []
   const loadPath = normalizePathParams(loadPoint.parts || [], allLoadParams, loadPoint.rename?.param)
 
@@ -377,6 +468,11 @@ function generateDirectList(model: Model, entity: ModelEntity, strict: boolean)
     return
   }
 
+  if ('graphql' === (listPoint as any).kind) {
+    generateDirectGraphql('list', entity, listPoint, strict)
+    return
+  }
+
   const listParams = listPoint.args?.params || []
   const listPath = normalizePathParams(listPoint.parts || [], listParams, listPoint.rename?.param)
 

package/project/.sdk/tm/ts/src/feature/test/TestFeature.ts

@@ -8,6 +8,35 @@ import { BaseFeature } from '../base/BaseFeature'
 const S_NOT_FOUND = 'Not found'
 
 
+// Which param is entity X's own identifier, as opposed to a parent key —
+// the load op's canonical point's LAST path segment, by construction (a
+// route addresses parents first, the record last). Mirrors recordKey in
+// sdkgen's Main_seneca-provider.ts; written again here because a template
+// ships standalone, outside that package. A renamed id (e.g. Airtable's
+// record_id) needs its own seeded field: matching only ever happens
+// against the API's real param names, never a bare 'id' the API itself
+// does not use.
+function ownIdField(config: any, getpath: any, entityName: string): string {
+  for (const opname of ['load', 'remove', 'update']) {
+    const points = getpath(config, ['entity', entityName, 'op', opname, 'points']) || []
+    const canonical = points.filter((pt: any) =>
+      null == (pt && pt.select && pt.select['$action']))
+    const use = 0 < canonical.length ? canonical : points
+    let best = use[0]
+    for (const pt of use) {
+      if (null == pt || null == pt.parts || null == best || null == best.parts) continue
+      const ptterm = 0 < pt.parts.length && String(pt.parts[pt.parts.length - 1]).startsWith('{')
+      const bestterm = 0 < best.parts.length && String(best.parts[best.parts.length - 1]).startsWith('{')
+      if (ptterm !== bestterm ? ptterm : pt.parts.length < best.parts.length) best = pt
+    }
+    const parts: string[] = (best && best.parts) || []
+    const last = [...parts].reverse().find((p: string) => p.startsWith('{'))
+    if (null != last) return last.slice(1, -1)
+  }
+  return 'id'
+}
+
+
 class TestFeature extends BaseFeature {
   version = '0.0.1'
   name = 'test'
@@ -30,10 +59,16 @@ class TestFeature extends BaseFeature {
 
     this._client._mode = 'test'
 
+    const getpath = struct.getpath
+
     // Ensure entity ids are correct.
     walk(entity, (k: any, v: any, _parent: any, path: any) => {
       if (2 === size(path)) {
         setprop(v, 'id', k)
+        const idField = ownIdField(ctx.config, getpath, String(path[0]))
+        if ('id' !== idField) {
+          setprop(v, idField, k)
+        }
       }
       return v
     })
@@ -172,6 +207,16 @@ class TestFeature extends BaseFeature {
 
         const ent = clone(ctx.reqdata)
         setprop(ent, 'id', id)
+
+        // A record created during the run needs the same real-key seeding
+        // the initial walk gives seed data (see ownIdField above) — without
+        // it, only `id` is set, and a load by the entity's own key right
+        // after create (recordKey !== 'id') finds nothing.
+        const idField = ownIdField(ctx.config, struct.getpath, getprop(op, 'entity'))
+        if ('id' !== idField && null == getprop(ent, idField)) {
+          setprop(ent, idField, id)
+        }
+
         setprop(entmap, id, ent)
         delprop(ent, '$KEY')
         const out = clone(ent)
@@ -310,7 +355,8 @@ class TestFeature extends BaseFeature {
 
 
 export {
-  TestFeature
+  TestFeature,
+  ownIdField,
 }
 
 

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "3.7.2",
+  "version": "3.7.3",
   "provides": {
     "target": [
       "c",

package/src/helpers/opShape.ts

@@ -680,6 +680,7 @@ export {
   entityCollection,
   opTypeName,
   opParams,
+  ownPoint,
   opActions,
   entityActions,
   entityPath,

package/src/sdkgen.ts

@@ -58,7 +58,7 @@ import { getMatchEntries } from './helpers/getMatchEntries'
 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 { OP_SUFFIX, opTypeName, opParams, ownPoint, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
 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'
@@ -1063,6 +1063,7 @@ export {
   OP_SUFFIX,
   opTypeName,
   opParams,
+  ownPoint,
   opActions,
   entityActions,
   entityPath,