@voxgig/sdkgen 4.34.0 → 4.34.1

package/src/helpers/modelNames.ts

@@ -16,6 +16,8 @@ type Rename = { from: string, to: string, key: string }
 // needs, since the key only moves when it was the name.
 type Plan = { from: string, to: string, origkey: string }
 
+type Member = { key: string, name: string, active: boolean }
+
 
 function guardModelNames(model: any, log?: any): Rename[] {
   const entity = model?.main?.[KIT]?.entity
@@ -23,6 +25,12 @@ function guardModelNames(model: any, log?: any): Rename[] {
     return []
   }
 
+  const digits = guardLeadingDigits(model, entity, log)
+  return digits.concat(guardFoldedNames(model, entity, digits, log))
+}
+
+
+function guardLeadingDigits(model: any, entity: any, log?: any): Rename[] {
   const flow = flowMap(model)
 
   const keys = Object.keys(entity).sort()
@@ -77,8 +85,142 @@ function guardModelNames(model: any, log?: any): Rename[] {
     return []
   }
 
-  const renames: Rename[] = []
+  const renames = applyPlans(model, entity, plans)
+
+  if (log?.warn) {
+    log.warn({
+      point: 'entity-name-guard', renames,
+      note: 'entity name(s) renamed so generated identifiers are legal: ' +
+        renames.map((r) => `${r.from} -> ${r.to}`).join(', ') +
+        '. If this project has a test fixture for one of them, move it: ' +
+        renames.map(fixtureMove).join('; '),
+    })
+  }
+
+  return renames
+}
+
+
+// Names whose generated identifiers or files meet once case is ignored, as
+// they do on macOS and Windows file systems and among PHP class and method
+// names. One entity of each such group keeps its name and the rest gain a
+// numeric suffix, chosen against every name the model holds.
+function guardFoldedNames(
+  model: any, entity: any, guarded: Rename[], log?: any,
+): Rename[] {
+  const keys = Object.keys(entity).sort()
+  const members: Member[] = keys
+    .filter((key) => null != entity[key] && 'object' === typeof entity[key])
+    .map((key) => ({
+      key,
+      name: 'string' === typeof entity[key].name ? entity[key].name : key,
+      active: false !== entity[key].active,
+    }))
+
+  const groups = foldGroups(members)
+  if (0 === groups.length) {
+    return []
+  }
+
+  const taken = new Set<string>()
+  keys.concat(members.map((m) => m.name))
+    .forEach((n) => foldKeys(n).forEach((f) => taken.add(f)))
+  const held = new Set<string>(keys)
+  const flow = flowMap(model)
+  const order = precedence(new Set(guarded.map((r) => r.to)))
+
+  const planned = groups.map((group) => {
+    const ranked = group.slice().sort(order)
+    const plans = ranked.slice(1).map((m) => {
+      const to = freeName(m.name, taken, held, flow)
+      foldKeys(to).forEach((f) => taken.add(f))
+      held.add(to)
+      return { from: m.name, to, origkey: m.key }
+    })
+    const routes = plans.map((p) => entityRoutes(entity[p.origkey]))
+    return { ranked, plans, routes }
+  })
+
+  const renames = applyPlans(model, entity, planned.flatMap((p) => p.plans))
+
+  if (log?.warn) {
+    for (const { ranked, plans, routes } of planned) {
+      log.warn({
+        point: 'entity-name-case-guard',
+        names: ranked.map((m) => m.name),
+        renames: plans.map(renameOf),
+        note: foldNote(ranked, plans.map(renameOf), routes),
+      })
+    }
+  }
+
+  return renames
+}
+
+
+// The forms a target derives from an entity name, as a case-insensitive
+// comparison sees them: the PascalCase class form, and the snake form the
+// C-family targets build by turning every other character into `_`.
+function foldKeys(name: string): string[] {
+  return [
+    'Name:' + pascalName(name).toLowerCase(),
+    'snake:' + name.replace(/[^A-Za-z0-9_]/g, '_').toLowerCase(),
+  ]
+}
+
+
+// Either form alone joins a pair of names, so a group is a connected component.
+function foldGroups(members: Member[]): Member[][] {
+  const root = members.map((_m, i) => i)
+  const find = (i: number): number => root[i] === i ? i : (root[i] = find(root[i]))
+  const first = new Map<string, number>()
+
+  members.forEach((m, i) => foldKeys(m.name).forEach((f) => {
+    const j = first.get(f)
+    if (null == j) {
+      first.set(f, i)
+    }
+    else {
+      root[find(i)] = find(j)
+    }
+  }))
+
+  const groups = new Map<number, Member[]>()
+  members.forEach((m, i) => {
+    const r = find(i)
+    groups.set(r, (groups.get(r) || []).concat(m))
+  })
+
+  return Array.from(groups.values()).filter((g) => 1 < g.length)
+}
+
+
+// The member that keeps its name sorts first: a name the model chose before
+// one a guard produced, an active entity before an inactive one, then
+// code-unit order.
+function precedence(byGuard: Set<string>): (a: Member, b: Member) => number {
+  const rank = (m: Member) => (byGuard.has(m.name) ? 2 : 0) + (m.active ? 0 : 1)
+  const cmp = (x: string, y: string) => x < y ? -1 : x > y ? 1 : 0
+  return (a, b) => rank(a) - rank(b) || cmp(a.name, b.name) || cmp(a.key, b.key)
+}
+
+
+function freeName(
+  name: string, taken: Set<string>, held: Set<string>,
+  flow: Record<string, any> | null,
+): string {
+  for (let n = 2; ; n++) {
+    const to = name + n
+    if (!held.has(to) &&
+      !foldKeys(to).some((f) => taken.has(f)) &&
+      (null == flow || !flowCollides(flow, name, to))) {
+      return to
+    }
+  }
+}
+
 
+function applyPlans(model: any, entity: any, plans: Plan[]): Rename[] {
   for (const { from, to, origkey } of plans) {
     const ent = entity[origkey]
     ent.name = to
@@ -92,27 +234,55 @@ function guardModelNames(model: any, log?: any): Rename[] {
       entity[to] = ent
       delete entity[origkey]
     }
-
-    renames.push({ from, to, key: origkey === from ? to : origkey })
   }
 
+  const renames = plans.map(renameOf)
   renameReferences(model, renames)
+  return renames
+}
 
-  if (log?.warn) {
-    log.warn({
-      point: 'entity-name-guard', renames,
-      note: 'entity name(s) renamed so generated identifiers are legal: ' +
-        renames.map((r) => `${r.from} -> ${r.to}`).join(', ') +
-        '. If this project has a test fixture for one of them, move it: ' +
-        renames.map((r) =>
-          `.sdk/test/entity/${r.from}/${pascalName(r.from)}TestData.json -> ` +
-          `.sdk/test/entity/${r.to}/${pascalName(r.to)}TestData.json ` +
-          `(renaming its \`existing.${r.from}\` key to \`${r.to}\`)`)
-          .join('; '),
-    })
+
+function renameOf({ from, to, origkey }: Plan): Rename {
+  return { from, to, key: origkey === from ? to : origkey }
+}
+
+
+function entityRoutes(ent: any): string[] {
+  const routes = new Set<string>()
+  for (const op of Object.values(ent?.op || {})) {
+    for (const pt of (op as any)?.points || []) {
+      if ('string' === typeof pt?.o && '' !== pt.o) {
+        routes.add(pt.o)
+      }
+    }
   }
+  return Array.from(routes).sort()
+}
 
-  return renames
+
+function foldNote(ranked: Member[], renames: Rename[], routes: string[][]): string {
+  const moves = renames.map((r, i) =>
+    0 === routes[i].length ? r.from : `${r.from} (${routes[i].join(', ')})`)
+  const offs = renames.map((r) => `guide: entity: ${r.from}: active: false`)
+
+  return `entity names ${ranked.map((m) => m.name).join(', ')} derive the ` +
+    `same identifier or file name once case is ignored ` +
+    `(${ranked.map((m) => pascalName(m.name)).join(', ')}): one file on a ` +
+    `case-insensitive filesystem (macOS, Windows), and one class in PHP. ` +
+    `Renamed ${renames.map((r) => `${r.from} -> ${r.to}`).join(', ')}; the ` +
+    `routes are unchanged. To choose the name yourself, move the operations ` +
+    `of ${moves.join(' and ')} to an entity named as you want in the guide ` +
+    `(.sdk/model/guide/guide.aontu), and switch the old one off there with ` +
+    `${offs.join(' and ')}. If this project has a test fixture for it, ` +
+    `move it: ${renames.map(fixtureMove).join('; ')}`
+}
+
+
+// The fixture is the project's own file, so a rename cannot carry it.
+function fixtureMove(r: Rename): string {
+  return `.sdk/test/entity/${r.from}/${pascalName(r.from)}TestData.json -> ` +
+    `.sdk/test/entity/${r.to}/${pascalName(r.to)}TestData.json ` +
+    `(renaming its \`existing.${r.from}\` key to \`${r.to}\`)`
 }
 
 

package/src/helpers/naming.ts

@@ -1,4 +1,7 @@
 
+import { CANON_OP_ORDER, deriveEntityNames, opTypeName } from './opShape'
+
+
 const JS_RESERVED = new Set<string>([
   'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger',
   'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false',
@@ -40,6 +43,11 @@ const LUA_RESERVED = new Set<string>([
   'then', 'true', 'until', 'while',
 ])
 
+const ELIXIR_RESERVED = new Set<string>([
+  'after', 'and', 'catch', 'do', 'else', 'end', 'false', 'fn', 'in', 'nil',
+  'not', 'or', 'rescue', 'true', 'when',
+])
+
 const RESERVED: Record<string, Set<string>> = {
   ts: JS_RESERVED,
   js: JS_RESERVED,
@@ -47,6 +55,7 @@ const RESERVED: Record<string, Set<string>> = {
   rb: RB_RESERVED,
   py: PY_RESERVED,
   lua: LUA_RESERVED,
+  elixir: ELIXIR_RESERVED,
 }
 
 
@@ -201,6 +210,175 @@ function tsSafeTypeName(Name: string): string {
 }
 
 
+// Erlang's zero-arity built-ins (`erl_internal:is_type/2`), Elixir's own, and
+// `record`, which compiles only with a warning that it overrides the built-in.
+const ELIXIR_BUILTIN_TYPES = new Set<string>([
+  'any', 'arity', 'atom', 'binary', 'bitstring', 'bool', 'boolean', 'byte',
+  'char', 'charlist', 'dynamic', 'float', 'function', 'identifier', 'integer',
+  'iodata', 'iolist', 'keyword', 'list', 'map', 'maybe_improper_list', 'mfa',
+  'module', 'neg_integer', 'nil', 'no_return', 'node', 'non_neg_integer',
+  'none', 'nonempty_binary', 'nonempty_bitstring', 'nonempty_charlist',
+  'nonempty_list', 'nonempty_maybe_improper_list', 'nonempty_string',
+  'number', 'pid', 'port', 'pos_integer', 'record', 'reference', 'string',
+  'struct', 'term', 'timeout', 'tuple', 'var',
+])
+
+
+function isElixirReservedType(name: string): boolean {
+  return ELIXIR_BUILTIN_TYPES.has(name) || ELIXIR_RESERVED.has(name)
+}
+
+
+// As tsSafeTypeName, for the bare entity type alone.
+function elixirSafeTypeName(name: string): string {
+  return isElixirReservedType(name) ? name + '_type' : name
+}
+
+
+// The name each entity takes over a whole collection: one the language
+// reserves takes `suffix`, and one that another entity already holds the
+// lowest free number from 2. `fold` compares as a case-insensitive language.
+function safeNames(all: string[], taken: string[], reserved: (name: string) => boolean,
+  suffix: string, fold = false): Record<string, string> {
+  const key = (name: string) => fold ? name.toLowerCase() : name
+  const held = new Set(taken.map(key))
+  const out: Record<string, string> = {}
+
+  for (const name of all) {
+    let safe = reserved(name) ? name + suffix : name
+    if (safe !== name) {
+      for (let n = 2; held.has(key(safe)); n++) {
+        safe = name + suffix + n
+      }
+      held.add(key(safe))
+    }
+    out[name] = safe
+  }
+  return out
+}
+
+
+function entityNames(entityColl: any): string[] {
+  return [...new Set(Object.values(entityColl || {})
+    .map((e: any) => e?.name)
+    .filter((n: any): n is string => 'string' === typeof n))]
+    .sort()
+}
+
+
+const _elixirTypeNames = new WeakMap<object, Record<string, string>>()
+
+// The bare type each entity declares in the one types module: a safe name
+// another entity already holds (`mfa` beside `mfa_type`) takes the lowest
+// free number from 2.
+function elixirTypeNames(entityColl: any): Record<string, string> {
+  const cached = _elixirTypeNames.get(entityColl)
+  if (null != cached) {
+    return cached
+  }
+
+  const all = entityNames(entityColl)
+  const out = safeNames(all, all.filter((n) => !isElixirReservedType(n)),
+    isElixirReservedType, '_type')
+
+  if (null != entityColl && 'object' === typeof entityColl) {
+    _elixirTypeNames.set(entityColl, out)
+  }
+  return out
+}
+
+
+function elixirTypeName(ent: any, entityColl: any): string {
+  return elixirTypeNames(entityColl)[ent?.name] ?? elixirSafeTypeName(ent?.name)
+}
+
+
+const _elixirAccessors = new WeakMap<object, Record<string, string>>()
+
+// The function the main module gives an entity (`Demo.widget(client)`). A
+// reserved word does not parse as one, so it takes `_entity`, numbered when
+// another entity already has that name.
+function elixirAccessorNames(entityColl: any): Record<string, string> {
+  const cached = _elixirAccessors.get(entityColl)
+  if (null != cached) {
+    return cached
+  }
+
+  const all = entityNames(entityColl)
+  const reserved = (name: string) => ELIXIR_RESERVED.has(name)
+  const out = safeNames(all, all.filter((n) => !reserved(n)), reserved, '_entity')
+
+  if (null != entityColl && 'object' === typeof entityColl) {
+    _elixirAccessors.set(entityColl, out)
+  }
+  return out
+}
+
+
+function elixirAccessor(ent: any, entityColl: any): string {
+  return elixirAccessorNames(entityColl)[ent?.name] ?? ent?.name
+}
+
+
+const TYPE_OPS = CANON_OP_ORDER
+
+const _typeNames = new WeakMap<object, Record<string, Record<string, string>>>()
+
+// The data type each entity declares, over the whole collection: an escaped
+// name never lands on a name another entity derives for a type or an op type.
+function typeNames(entityColl: any, lang: string, reserved: (Name: string) => boolean,
+  fold = false): Record<string, string> {
+  const byLang = _typeNames.get(entityColl) || {}
+  if (null != byLang[lang]) {
+    return byLang[lang]
+  }
+
+  const ents = deriveEntityNames(entityColl)
+  const all = [...new Set(ents.map((e: any) => String(e.Name)))].sort()
+  const taken: string[] = []
+  for (const e of ents) {
+    if (!reserved(e.Name)) {
+      taken.push(e.Name)
+    }
+    for (const op of TYPE_OPS) {
+      if (e.op && e.op[op]) {
+        taken.push(opTypeName(e.Name, op))
+      }
+    }
+  }
+
+  byLang[lang] = safeNames(all, taken, reserved, 'Type', fold)
+  if (null != entityColl && 'object' === typeof entityColl) {
+    _typeNames.set(entityColl, byLang)
+  }
+  return byLang[lang]
+}
+
+
+function tsTypeName(ent: any, entityColl: any): string {
+  return typeNames(entityColl, 'ts', (N) => isTsReservedType(N) || isTsSdkType(N))[ent?.Name] ??
+    tsSafeTypeName(ent?.Name)
+}
+
+
+function rbTypeName(ent: any, entityColl: any): string {
+  return typeNames(entityColl, 'rb', (N) => isRbCoreConstant(N) || isRbSdkConstant(N))[ent?.Name] ??
+    rbSafeTypeName(ent?.Name)
+}
+
+
+// PHP compares class names ignoring case.
+function phpTypeName(ent: any, entityColl: any): string {
+  return typeNames(entityColl, 'php', (N) => isPhpReservedType(N) || isPhpSdkClass(N), true)[ent?.Name] ??
+    phpSafeTypeName(ent?.Name)
+}
+
+
+function swiftTypeName(ent: any, entityColl: any): string {
+  return typeNames(entityColl, 'swift', isSwiftSdkType)[ent?.Name] ?? swiftSafeTypeName(ent?.Name)
+}
+
+
 function isReservedName(name: string, lang: string): boolean {
   const set = RESERVED[lang]
   return !!set && set.has(name)
@@ -320,6 +498,16 @@ export {
   isTsReservedType,
   isTsSdkType,
   tsSafeTypeName,
+  isElixirReservedType,
+  elixirSafeTypeName,
+  elixirTypeNames,
+  elixirTypeName,
+  elixirAccessorNames,
+  elixirAccessor,
+  tsTypeName,
+  rbTypeName,
+  phpTypeName,
+  swiftTypeName,
   jsProp,
   jsOptProp,
   jsKey,

package/src/helpers/npm.ts

@@ -0,0 +1,68 @@
+import Fs from 'node:fs'
+import Path from 'node:path'
+
+
+// The parts of the running process that decide how npm is run.
+type NpmHost = {
+  platform: string
+  env: Record<string, string | undefined>
+  execPath: string
+  exists: (path: string) => boolean
+}
+
+type NpmCommand = {
+  file: string
+  args: string[]
+}
+
+
+const PROCESS_HOST: NpmHost = {
+  platform: process.platform,
+  env: process.env,
+  execPath: process.execPath,
+  exists: (path: string) => Fs.existsSync(path),
+}
+
+
+// On Windows npm and npx are batch files, which node spawns only through a
+// shell that re-parses every argument. Their JS entries run under this node
+// instead, so no shell starts and each argument reaches npm as given.
+function npmCommand(
+  tool: 'npm' | 'npx', args: string[], host: NpmHost = PROCESS_HOST,
+): NpmCommand {
+  if ('win32' !== host.platform) {
+    return { file: tool, args }
+  }
+
+  const cli = npmCli(host)
+  const entry = 'npm' === tool ? cli : Path.win32.join(Path.win32.dirname(cli), 'npx-cli.js')
+  return { file: host.execPath, args: [entry, ...args] }
+}
+
+
+// npm sets npm_execpath to its own npm-cli.js; yarn and pnpm set it to theirs.
+function npmCli(host: NpmHost): string {
+  const launcher = host.env.npm_execpath
+  const candidates = [
+    ...('string' === typeof launcher && 'npm-cli.js' === Path.win32.basename(launcher)
+      ? [launcher] : []),
+    Path.win32.join(Path.win32.dirname(host.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ]
+
+  const found = candidates.find((path) => host.exists(path))
+  if (null == found) {
+    throw new Error('npm-cli.js was not found (looked for ' + candidates.join(', ') +
+      '), so npm cannot be run without a shell')
+  }
+  return found
+}
+
+
+export type {
+  NpmCommand,
+  NpmHost,
+}
+
+export {
+  npmCommand,
+}

package/src/helpers/npmScripts.ts

@@ -0,0 +1,37 @@
+
+// npm runs a script through sh on POSIX and cmd.exe on Windows, which has no
+// single quotes, sh variable expansion, inline assignment or `rm`. These say
+// the same things through node itself, inside double quotes neither shell
+// expands.
+
+function npmScriptRm(paths: string[]): string {
+  return 'node -e "for (const p of process.argv.slice(1)) ' +
+    'require(\'fs\').rmSync(p, { recursive: true, force: true })" ' + paths.join(' ')
+}
+
+
+function npmScriptEnv(name: string, value: string): string {
+  return `--import "data:text/javascript,process.env.${name}='${value}'"`
+}
+
+
+// The pattern comes from `npm run test-some --pattern=<regexp>`, or from
+// TEST_PATTERN; without one, every test runs.
+function npmScriptTestSome(nodeArgs: string[], glob: string): string {
+  const args = [
+    ...nodeArgs.map((arg) => `'${arg}'`),
+    '...(p ? [\'--test-name-pattern=\' + p] : [])',
+    '\'--test\'',
+    `'${glob}'`,
+  ]
+  return 'node -e "const p = process.env.npm_config_pattern || process.env.TEST_PATTERN; ' +
+    'const r = require(\'child_process\').spawnSync(process.execPath, [' + args.join(', ') +
+    '], { stdio: \'inherit\' }); process.exit(r.status ?? 1)"'
+}
+
+
+export {
+  npmScriptRm,
+  npmScriptEnv,
+  npmScriptTestSome,
+}

package/src/helpers/opExample.ts

@@ -1,13 +1,16 @@
 
 import { each } from 'jostraca'
 import { canonKey } from './canonType'
-import { opRequestShape, entityIdField } from './opShape'
+import { opRequestShape, opParams, entityIdField } from './opShape'
 
 import { phpEntityAccessor } from './naming'
 
 
 type ExampleLang = 'ts' | 'js' | 'py' | 'php' | 'rb' | 'lua' | 'go'
 
+// The languages a literal is written in: the call languages, and JSON.
+type LiteralLang = ExampleLang | 'json'
+
 
 function cap(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1)
@@ -15,7 +18,7 @@ function cap(s: string): string {
 
 
 // A type-correct literal for a canonical type sentinel, in the target language.
-function litFor(lang: ExampleLang, type: any): string {
+function litFor(lang: LiteralLang, type: any): string {
   const k = canonKey(type)
   if ('INTEGER' === k || 'NUMBER' === k) return '1'
   if ('BOOLEAN' === k) return 'py' === lang ? 'True' : ('rb' === lang ? 'true' : 'true')
@@ -48,12 +51,13 @@ function idLiteral(ent: any, op: string, idF: string | null): string {
 const JS_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/
 const LUA_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/
 
-function litPair(lang: ExampleLang, name: string, value: string): string {
+function litPair(lang: LiteralLang, name: string, value: string): string {
   switch (lang) {
     case 'py': return `"${name}": ${value}`
     case 'php': return `"${name}" => ${value}`
     case 'rb': return `"${name}" => ${value}`
     case 'go': return `"${name}": ${value}`
+    case 'json': return `${JSON.stringify(name)}: ${value}`
     case 'lua': return LUA_IDENT.test(name) ?
       `${name} = ${value}` : `["${name}"] = ${value}`
     default: return JS_IDENT.test(name) ?
@@ -63,10 +67,10 @@ function litPair(lang: ExampleLang, name: string, value: string): string {
 
 
 function matchArg(
-  lang: ExampleLang, ent: any, op: string, idF: string | null, idLit: string
+  lang: LiteralLang, ent: any, op: string, idF: string | null, idLit: string
 ): string {
   const items = opRequestShape(ent, op).items.filter((it: any) => !it.optional)
-  if (0 === items.length) return 'go' === lang ? 'nil' : ''
+  if (0 === items.length) return 'go' === lang ? 'nil' : ('json' === lang ? '{}' : '')
   const pairs = items.map((it: any) =>
     litPair(lang, it.name, it.name === idF ? idLit : litFor(lang, it.type)))
   switch (lang) {
@@ -78,12 +82,17 @@ function matchArg(
 }
 
 
-function dataArg(lang: ExampleLang, ent: any, op: string, idF: string | null): string {
+// An update or patch addressed only by id and route also changes a field.
+function dataArg(lang: LiteralLang, ent: any, op: string, idF: string | null): string {
+  const routed = new Set(opParams(ent?.op?.[op]).map((p: any) => p.n))
+  const addresses = (it: any) => it.name === idF || it.name === 'id' || routed.has(it.name)
   const items = opRequestShape(ent, op).items
     .filter((it: any) =>
       (it.name !== idF && it.name !== 'id') || !it.optional)
   const required = items.filter((it: any) => !it.optional)
-  const chosen = required.length ? required : items.slice(0, 3)
+  const changed = ('update' === op || 'patch' === op) && required.every(addresses) ?
+    items.filter((it: any) => it.optional && !addresses(it)).slice(0, 1) : []
+  const chosen = required.length ? [...required, ...changed] : items.slice(0, 3)
   const pairs = chosen.map((it: any) => litPair(lang, it.name, litFor(lang, it.type)))
   switch (lang) {
     case 'php': return `[${pairs.join(', ')}]`
@@ -115,7 +124,7 @@ function primaryOpCall(
 ): PrimaryCall {
   const isMatch = 'load' === op || 'remove' === op
   const isList = 'list' === op
-  const isData = 'create' === op || 'update' === op
+  const isData = 'create' === op || 'update' === op || 'patch' === op
   const idLit = idLiteral(ent, op, idF)
 
   const method = 'go' === lang ? cap(op) : op
@@ -131,9 +140,7 @@ function primaryOpCall(
   else { factory = `client.${eName}()`; sep = '.' }
 
   let arg: string
-  if (isList) {
-    arg = 'go' === lang ? 'nil' : ''
-  } else if (isMatch) {
+  if (isList || isMatch) {
     arg = matchArg(lang, ent, op, idF, idLit)
   } else if (isData) {
     arg = dataArg(lang, ent, op, idF)
@@ -160,5 +167,6 @@ export {
 
 export type {
   ExampleLang,
+  LiteralLang,
   PrimaryCall,
 }