@voxgig/sdkgen 4.34.0 → 4.34.2

package/src/helpers/opShape.ts

@@ -3,6 +3,9 @@ import { each, names } from 'jostraca'
 import { KIT, getModelPath } from '@voxgig/apidef'
 
 import { pointSegments, pointTerminalParam, pointPathKey } from './pointPath'
+import { canonKey } from './canonType'
+
+import type { TargetOrigins } from '../action/resolve'
 
 
 const _entityCollCache = new WeakMap<object, any>()
@@ -30,14 +33,15 @@ function deriveEntityNames(entityColl: any): any[] {
 }
 
 
-// The five ops, and whether their request payload is a `Match` (query/id) or
-// `Data` (body) — this fixes the generated type-name suffix per op.
+// The generated ops, and whether their request payload is a `Match`
+// (query/id) or `Data` (body) — this fixes the generated type-name suffix per op.
 const OP_SUFFIX: Record<string, 'Match' | 'Data'> = {
   load: 'Match',
   list: 'Match',
   remove: 'Match',
   create: 'Data',
   update: 'Data',
+  patch: 'Data',
 }
 
 
@@ -85,7 +89,7 @@ function entityActions(entity: any): { op: string, action: string, path: string
 function entityPath(entity: any): string {
   const ops: any = (entity && entity.op) || {}
 
-  for (const opname of ['list', 'load', 'create', 'update', 'remove']) {
+  for (const opname of CANON_OP_ORDER) {
     const op = ops[opname]
     if (null == op) {
       continue
@@ -136,17 +140,70 @@ function samePath(points: any[]): boolean {
 }
 
 
-function opParams(op: any): any[] {
-  let points: any[] = op && op.points ? each(op.points) : []
+// A placeholder inside a literal segment needs a value too.
+function pointParams(point: any): string[] {
+  const names: string[] = []
+  for (const seg of pointSegments(point)) {
+    if (null != seg.var) {
+      names.push(String(seg.var))
+    }
+    else {
+      for (const found of String(seg.lit ?? '').matchAll(/\{([^{}/]+)\}/g)) {
+        names.push(found[1])
+      }
+    }
+  }
+  return names
+}
+
+
+// The rule makePoint applies: a lone point is taken as it is, otherwise only
+// a point without an action, and one the call fills.
+function opReachable(op: any, given: string[]): boolean {
+  const points: any[] = op && op.points ? each(op.points) : []
+  const have = new Set(given)
+  const fills = (pt: any) => pointParams(pt).every((name) => have.has(name))
 
+  if (1 === points.length) {
+    return fills(points[0])
+  }
+
+  return points.some((pt: any) => null == (pt && pt.q && pt.q['$action']) && fills(pt))
+}
+
+
+function opNeedsAction(op: any): boolean {
+  const points: any[] = op && op.points ? each(op.points) : []
+  return 1 < points.length &&
+    points.every((pt: any) => null != (pt && pt.q && pt.q['$action']))
+}
+
+
+// The points a call can select: an action's only where every point is one.
+function selectablePoints(op: any): any[] {
+  const points: any[] = op && op.points ? each(op.points) : []
   const canonical = points.filter((pt: any) =>
     null == (pt && pt.q && pt.q['$action']))
-  if (0 < canonical.length) {
-    points = canonical
-  }
+  return 0 < canonical.length ? canonical : points
+}
+
+
+// The route and query parameters a point requires.
+function pointRequires(pt: any): string[] {
+  const params = [
+    ...(pt && pt.g && pt.g.params ? each(pt.g.params) : []),
+    ...(pt && pt.g && pt.g.query ? each(pt.g.query) : []),
+  ]
+  return params.filter((p: any) => p && null != p.n && false !== p.r).map((p: any) => p.n)
+}
 
-  const seen: Record<string, any> = {}
-  const requiredOnAll: Record<string, boolean> = {}
+
+function opParams(op: any): any[] {
+  const points = selectablePoints(op)
+
+  // Keyed by parameter name, which may be `__proto__`.
+  const seen: Record<string, any> = Object.create(null)
+  const requiredOnAll: Record<string, boolean> = Object.create(null)
   const out: any[] = []
 
   points.forEach((pt: any, pointIndex: number) => {
@@ -155,7 +212,7 @@ function opParams(op: any): any[] {
     const pathParams = pt && pt.g && pt.g.params ? each(pt.g.params) : []
     const queryParams = pt && pt.g && pt.g.query ? each(pt.g.query) : []
     const params = [...pathParams, ...queryParams]
-    const requiredHere: Record<string, boolean> = {}
+    const requiredHere: Record<string, boolean> = Object.create(null)
     params.forEach((p: any) => {
       if (p && null != p.n) {
         requiredHere[p.n] = false !== p.r
@@ -196,6 +253,7 @@ function fieldOptional(field: any, opname: string): boolean {
     case 'create':
       return false === field.r
     case 'update':
+    case 'patch':
       return true
     case 'load':
     case 'remove':
@@ -274,21 +332,147 @@ function entityIdField(ent: any): string | null {
 }
 
 
-// The entity's ACTIVE op names, in canonical CRUD order (list, load, create,
-// update, remove), with any non-canonical ops appended in sorted order. Doc
-// generators must gate an op example on this (an op present in the model but
-// `active: false` generates no method, so an example calling it would not
-// compile) — NOT on the raw `Object.keys(ent.op)`, which includes inactive ops.
-const CANON_OP_ORDER = ['list', 'load', 'create', 'update', 'remove']
+// A value of another type for each scalar item type, which validate rejects.
+const MISTYPED: Record<string, any> = {
+  STRING: 1,
+  NUMBER: 'x',
+  INTEGER: 'x',
+  BOOLEAN: 'x',
+}
+
+const WELLTYPED: Record<string, any> = {
+  STRING: 'x',
+  NUMBER: 1,
+  INTEGER: 1,
+  BOOLEAN: true,
+}
+
+
+// A request the validate feature rejects: the first generated operation whose
+// request has a scalar-typed item, that item mistyped and every other required
+// one filled, so the call still resolves its route.
+function invalidRequest(ent: any):
+  { op: string, field: string, args: Record<string, any> } | null {
+
+  for (const opname of entityOps(ent).filter((o) => CANON_OP_ORDER.includes(o))) {
+    const { items } = opRequestShape(ent, opname)
+    const bad = items.find((it: OpShapeItem) => null != MISTYPED[canonKey(it.type)])
+    if (null == bad) {
+      continue
+    }
+
+    const args: Record<string, any> = {}
+    for (const it of items) {
+      if (it === bad) {
+        args[it.name] = MISTYPED[canonKey(it.type)]
+      }
+      else if (!it.optional) {
+        args[it.name] = WELLTYPED[canonKey(it.type)] ?? 'x'
+      }
+    }
+
+    if (opReachable(ent.op[opname], Object.keys(args))) {
+      return { op: opname, field: bad.name, args }
+    }
+  }
+
+  return null
+}
+
+
+// The entity's ACTIVE op names, in canonical CRUD order, then any others
+// sorted. Doc generators gate an op example on this, NOT on the raw
+// `Object.keys(ent.op)`: an `active: false` op generates no method, and an op
+// whose every route is an action is refused without one, so a plain example
+// of either would fail.
+const CANON_OP_ORDER = ['list', 'load', 'create', 'update', 'patch', 'remove']
 
 function entityOps(ent: any): string[] {
   const ops = (ent && ent.op) || {}
-  const active = Object.keys(ops).filter((o: string) => ops[o] && ops[o].active !== false)
+  const active = Object.keys(ops).filter((o: string) =>
+    ops[o] && ops[o].active !== false && !opNeedsAction(ops[o]))
   return CANON_OP_ORDER.filter((o) => active.includes(o))
     .concat(active.filter((o) => !CANON_OP_ORDER.includes(o)).sort())
 }
 
 
+type UngeneratedOp = { entity: string, op: string, points: string[] }
+
+
+// Every bundled target emits a method for the CANON_OP_ORDER ops and nothing
+// else, so any other active op of an active entity has none in those SDKs.
+function ungeneratedOps(model: any): UngeneratedOp[] {
+  const entity = model?.main?.[KIT]?.entity
+  if (null == entity || 'object' !== typeof entity) {
+    return []
+  }
+
+  const out: UngeneratedOp[] = []
+
+  for (const key of Object.keys(entity).sort()) {
+    const ent = entity[key]
+    if (null == ent || 'object' !== typeof ent || false === ent.active) {
+      continue
+    }
+
+    const ops = ent.op || {}
+    for (const opname of Object.keys(ops).sort()) {
+      const op = ops[opname]
+      if (null == op || 'object' !== typeof op || false === op.active ||
+        CANON_OP_ORDER.includes(opname)) {
+        continue
+      }
+
+      const points = (Array.isArray(op.points) ? op.points : [])
+        .filter((pt: any) => null != pt && false !== pt.a)
+        .map((pt: any) => [pt.m, pt.o].filter((s: any) => null != s).join(' '))
+
+      out.push({
+        entity: 'string' === typeof ent.name ? ent.name : key,
+        op: opname,
+        points,
+      })
+    }
+  }
+
+  return out
+}
+
+
+// Speaks only for the bundled targets: a target from another package may
+// generate more ops, so it is named as outside the claim rather than judged.
+function warnUngeneratedOps(
+  model: any, log: any, origins: TargetOrigins,
+): UngeneratedOp[] {
+  const dropped = 0 === origins.bundled.length ? [] : ungeneratedOps(model)
+  if (0 < dropped.length && log && log.warn) {
+    const listed = dropped.map((d) => `${d.entity}.${d.op}` +
+      (0 < d.points.length ? ` (${d.points.join(', ')})` : ''))
+    const generated = CANON_OP_ORDER.slice(0, -1).join(', ') + ' and ' +
+      CANON_OP_ORDER[CANON_OP_ORDER.length - 1]
+    const external = origins.external.map((t) => `${t.name} from ${t.from}`)
+    log.warn({
+      point: 'entity-op-ungenerated', ops: dropped,
+      bundled: origins.bundled, external: origins.external,
+      note: 0 === external.length
+        ? `operation(s) in the model that the bundled targets do not ` +
+        `generate (each generates ${generated} only), so the SDK has no ` +
+        `method for them: ${listed.join(', ')}. To reach one, reclassify it ` +
+        `in the guide (.sdk/model/guide/guide.aontu); to accept the gap, ` +
+        `switch it off there with op: <name>: active: false on its path`
+        : `operation(s) in the model that the bundled targets ` +
+        `(${origins.bundled.join(', ')}) do not generate (each generates ` +
+        `${generated} only), so their SDKs have no method for them: ` +
+        `${listed.join(', ')}. Targets installed from elsewhere may ` +
+        `generate them, so they are not judged here: ${external.join(', ')}. ` +
+        `To reach one in a bundled target, reclassify it in the guide ` +
+        `(.sdk/model/guide/guide.aontu)`,
+    })
+  }
+  return dropped
+}
+
+
 // The entity's primary/representative op for a single illustrative call —
 // prefer a read op (list, then load) so the snippet needs no fabricated match,
 // then fall back to create/update/remove. null when the entity exposes no op.
@@ -306,21 +490,26 @@ function entityPrimaryOp(ent: any): string | null {
 
 
 const _classNameCache = new WeakMap<object, Record<string, string>>()
+const _classNameCacheFold = new WeakMap<object, Record<string, string>>()
 
-function entityClassNames(entityColl: any): Record<string, string> {
-  const cached = _classNameCache.get(entityColl)
+// `fold` compares names as PHP does, ignoring case: the data type `Fooentity`
+// and the class `FooEntity` are one name to it.
+function entityClassNames(entityColl: any, fold = false): Record<string, string> {
+  const cache = fold ? _classNameCacheFold : _classNameCache
+  const cached = cache.get(entityColl)
   if (null != cached) {
     return cached
   }
 
+  const key = (name: string) => fold ? name.toLowerCase() : name
   const ents = deriveEntityNames(entityColl)
 
-  const taken: Record<string, boolean> = {}
+  const taken = new Set<string>()
   ents.forEach((e: any) => {
-    taken[e.Name] = true
-    for (const op of ['load', 'list', 'create', 'update', 'remove']) {
+    taken.add(key(e.Name))
+    for (const op of CANON_OP_ORDER) {
       if (e.op && e.op[op]) {
-        taken[opTypeName(e.Name, op)] = true
+        taken.add(key(opTypeName(e.Name, op)))
       }
     }
   })
@@ -329,50 +518,53 @@ function entityClassNames(entityColl: any): Record<string, string> {
   const out: Record<string, string> = {}
   ents.forEach((e: any) => {
     let name = e.Name + 'Entity'
-    if (taken[name]) {
+    if (taken.has(key(name))) {
       const base = name + 'Client'
       name = base
       let n = 1
-      while (taken[name]) {
+      while (taken.has(key(name))) {
         n++
         name = base + n
       }
     }
-    taken[name] = true
+    taken.add(key(name))
     out[e.name] = name
   })
 
-  _classNameCache.set(entityColl, out)
+  cache.set(entityColl, out)
   return out
 }
 
 
 // The collision-free class name for one entity (see entityClassNames).
 // `entityColl` is main.<KIT>.entity (the collection the entity belongs to).
-function entityClassName(ent: any, entityColl: any): string {
+function entityClassName(ent: any, entityColl: any, fold = false): string {
   if (null == ent) {
     return ''
   }
-  const map = entityClassNames(entityColl)
+  const map = entityClassNames(entityColl, fold)
   return map[ent.name] || (ent.Name + 'Entity')
 }
 
 
 const _typeCollisionCache = new WeakMap<object, string[]>()
+const _typeCollisionCacheFold = new WeakMap<object, string[]>()
 
-function entityTypeCollisions(entityColl: any): string[] {
-  const cached = _typeCollisionCache.get(entityColl)
+function entityTypeCollisions(entityColl: any, fold = false): string[] {
+  const cache = fold ? _typeCollisionCacheFold : _typeCollisionCache
+  const cached = cache.get(entityColl)
   if (null != cached) {
     return cached
   }
 
+  const key = (name: string) => fold ? name.toLowerCase() : name
   const counts: Record<string, number> = {}
-  const bump = (n: string) => { counts[n] = (counts[n] || 0) + 1 }
+  const bump = (n: string) => { counts[key(n)] = (counts[key(n)] || 0) + 1 }
 
   deriveEntityNames(entityColl)
     .forEach((e: any) => {
       bump(e.Name)
-      for (const op of ['load', 'list', 'create', 'update', 'remove']) {
+      for (const op of CANON_OP_ORDER) {
         if (e.op && e.op[op]) {
           bump(opTypeName(e.Name, op))
         }
@@ -380,7 +572,7 @@ function entityTypeCollisions(entityColl: any): string[] {
     })
 
   const out = Object.keys(counts).filter((n) => 1 < counts[n]).sort()
-  _typeCollisionCache.set(entityColl, out)
+  cache.set(entityColl, out)
   return out
 }
 
@@ -388,7 +580,7 @@ function entityTypeCollisions(entityColl: any): string[] {
 // Emitter convenience: warn (once per collection per target run) when the
 // generated typed model would contain duplicate top-level type names.
 function warnEntityTypeCollisions(entityColl: any, log: any, lang: string): string[] {
-  const dups = entityTypeCollisions(entityColl)
+  const dups = entityTypeCollisions(entityColl, 'php' === lang)
   if (0 < dups.length && log && log.warn) {
     log.warn({
       point: 'entity-types-name-collision', lang, names: dups,
@@ -415,11 +607,32 @@ function pickExampleEntity(entity: any): { entity: any, primaryOp: string | null
   // representative entity, not the alphabetically-first one (often a degenerate
   // stub with a terse name and no fields) nor an atypically sprawling one.
   const pool = readable.length ? readable : (withOp.length ? withOp : actives)
-  const chosen = pickMedianEntity(pool)
+  let chosen = pickMedianEntity(pool)
+  // A bare list example cannot fill a nested route: prefer a reachable call.
+  if (null != chosen && !exampleReachable(chosen)) {
+    const reachable = pool.filter(exampleReachable)
+    if (0 < reachable.length) {
+      chosen = pickMedianEntity(reachable)
+    }
+  }
   return { entity: chosen, primaryOp: null == chosen ? null : entityPrimaryOp(chosen) }
 }
 
 
+// A list example passes nothing; the others pass the required members.
+function exampleReachable(ent: any): boolean {
+  const opname = entityPrimaryOp(ent)
+  if (null == opname) {
+    return false
+  }
+  const idF = entityIdField(ent)
+  const given = 'list' === opname ? [] : opRequestShape(ent, opname).items
+    .filter((it: OpShapeItem) => !it.optional || it.name === idF)
+    .map((it: OpShapeItem) => it.name)
+  return opReachable(ent.op[opname], given)
+}
+
+
 // The pool entity closest to the median on both axes (name length, field
 // count). Distance on each axis is normalised by that axis's own median so the
 // two are comparable, then summed. Ties keep the pool's existing key-sorted
@@ -474,11 +687,16 @@ function entityDataIdField(ent: any): string | null {
 
 
 export {
+  CANON_OP_ORDER,
   OP_SUFFIX,
   deriveEntityNames,
   entityCollection,
   opTypeName,
   opParams,
+  selectablePoints,
+  pointRequires,
+  opReachable,
+  opNeedsAction,
   ownPoint,
   opActions,
   entityActions,
@@ -487,13 +705,17 @@ export {
   entityIdField,
   entityDataIdField,
   entityOps,
+  invalidRequest,
   entityPrimaryOp,
   pickExampleEntity,
   entityClassName,
   entityTypeCollisions,
   warnEntityTypeCollisions,
+  ungeneratedOps,
+  warnUngeneratedOps,
 }
 
 export type {
   OpShapeItem,
+  UngeneratedOp,
 }

package/src/helpers/optional.ts

@@ -0,0 +1,76 @@
+
+import { loadOptional } from '../utility'
+
+
+const DOCS = 'https://github.com/voxgig/sdkgen/blob/main/docs/how-to/' +
+  'author-a-new-language.md#optional-readme-components'
+
+
+// What a target's documentation goes without when the target does not supply
+// the component. Null where a shared default renders in its place.
+const OPTIONAL_COMPONENTS = {
+  AgentGuide: null,
+  ReadmeFeatures: null,
+  ReadmeModel: null,
+
+  ReadmeIntro: (t: string) => t + '/README.md has no title or introduction',
+  ReadmeInstall: (t: string) => t + "/README.md's install section is empty",
+  ReadmeQuick: (t: string) => t + "/README.md's tutorial is empty",
+  ReadmeHowto: (t: string) => t + "/README.md's how-to section is empty",
+  ReadmeOptions: (t: string) => t + '/README.md has no options section',
+  ReadmeEntity: (t: string) => t + '/README.md has no entities section',
+  ReadmeExplanation: (t: string) =>
+    t + "/README.md's advanced section has nothing specific to " + t,
+  ReadmeRef: (t: string) =>
+    t + '/REFERENCE.md is not written, though ' + t + '/README.md links to it',
+  ReadmeTopQuick: (t: string) =>
+    "the top-level README.md's quickstart has no " + t + ' example',
+  ReadmeTopTest: (t: string) =>
+    "the top-level README.md's offline testing section has no " + t + ' example',
+  ReadmeTopHowto: (t: string) =>
+    "the top-level README.md's direct call guide has no " + t + ' example',
+}
+
+
+type OptionalComponent = keyof typeof OPTIONAL_COMPONENTS
+
+
+function optionalComponent(ctx$: any, target: any, name: OptionalComponent): any {
+  const t = target.name
+  const found = loadOptional(ctx$, `./cmp/${t}/${name}_${t}`)
+
+  if (undefined !== found) {
+    return found
+  }
+
+  const lacks = OPTIONAL_COMPONENTS[name]
+  const file = `.sdk/src/cmp/${t}/${name}_${t}.ts`
+
+  if (null == lacks) {
+    ctx$.log?.debug?.({
+      point: 'optional-component-default', target: t, component: name,
+      note: t + ': no ' + name + '_' + t + ' component, so the shared default is used',
+    })
+    return undefined
+  }
+
+  ctx$.log.warn({
+    point: 'optional-component-missing', target: t, component: name, file,
+    note: t + ': no ' + name + '_' + t + ' component, so ' + lacks(t) +
+      '. The SDK code is complete; only this documentation is affected. ' +
+      'To add it, write ' + file + ' (for a target from a package, in that ' +
+      'package) and run npm run generate. See ' + DOCS,
+  })
+
+  return undefined
+}
+
+
+export type {
+  OptionalComponent,
+}
+
+export {
+  OPTIONAL_COMPONENTS,
+  optionalComponent,
+}

package/src/helpers/packageMeta.ts

@@ -4,6 +4,7 @@ import { each } from 'jostraca'
 import { KIT, nom } from '@voxgig/apidef'
 
 import { kindCollection } from './kindCollection'
+import { modelText } from './text'
 
 const PUBLISHER = 'Voxgig'
 const PUBLISHER_URL = 'https://voxgig.com'
@@ -51,6 +52,7 @@ function repoInfo(model: any) {
   const repo = seg[seg.length - 1]
 
   const repoUrl = `https://${host}/${path}`
+  const pages = repoPages(host, repoUrl)
 
   return {
     slug,
@@ -59,10 +61,42 @@ function repoInfo(model: any) {
     path,
     repo,
     repoUrl,
-    issuesUrl: `${repoUrl}/issues`,
-    changelogUrl: `${repoUrl}/blob/main/CHANGELOG.md`,
-    releasesUrl: `${repoUrl}/releases`,
-    tagsUrl: `${repoUrl}/tags`,
+    hostName: pages.name,
+    issuesUrl: pages.issues,
+    changelogUrl: pages.changelog,
+    releasesUrl: pages.releases,
+    tagsUrl: pages.tags,
+  }
+}
+
+
+// GitLab keeps a project's pages under `/-/`, and Bitbucket lists its tags
+// among its downloads; any other host is laid out as GitHub is.
+function repoPages(host: string, repoUrl: string) {
+  if (host.includes('gitlab')) {
+    return {
+      name: 'GitLab',
+      issues: `${repoUrl}/-/issues`,
+      changelog: `${repoUrl}/-/blob/main/CHANGELOG.md`,
+      releases: `${repoUrl}/-/releases`,
+      tags: `${repoUrl}/-/tags`,
+    }
+  }
+  if ('bitbucket.org' === host) {
+    return {
+      name: 'Bitbucket',
+      issues: `${repoUrl}/issues`,
+      changelog: `${repoUrl}/src/main/CHANGELOG.md`,
+      releases: `${repoUrl}/downloads/?tab=tags`,
+      tags: `${repoUrl}/downloads/?tab=tags`,
+    }
+  }
+  return {
+    name: host.includes('github') ? 'GitHub' : host,
+    issues: `${repoUrl}/issues`,
+    changelog: `${repoUrl}/blob/main/CHANGELOG.md`,
+    releases: `${repoUrl}/releases`,
+    tags: `${repoUrl}/tags`,
   }
 }
 
@@ -186,7 +220,7 @@ function vendorCommand(model: any, target: string): string {
 }
 
 function apiName(model: any): string {
-  const info = (model.main && model.main[KIT] && model.main[KIT].info) || {}
+  const info = modelText(model)
   const raw = (null != info.title ? String(info.title) : '').trim()
   const stripped = raw.replace(/\s*API\s*$/i, '').trim()
   return stripped || nom(model, 'Name') || model.name
@@ -284,12 +318,46 @@ function pkgDescription(model: any, target: string): string {
 // reliably known across the fleet).
 function nonAffiliation(model: any): string {
   return `This is an unofficial SDK for the ${apiName(model)} public API, generated by ` +
-    `${PUBLISHER} with [\`@voxgig/sdkgen\`](${GENERATOR_URL}). ` +
+    `${publisherInfo(model).name} with [\`@voxgig/sdkgen\`](${GENERATOR_URL}). ` +
     `It is not affiliated with, endorsed by, or sponsored by the upstream API provider.`
 }
 
 function keywords(model: any): string[] {
-  return ['voxgig', 'sdk', 'generated-sdk', 'openapi', 'api-client', model.name]
+  return [...(isDefaultPublisher(model) ? ['voxgig'] : []),
+    'sdk', 'generated-sdk', 'openapi', 'api-client', model.name]
+}
+
+
+function declaredText(value: any): string {
+  return null != value && '' !== value ? String(value) : ''
+}
+
+
+// Voxgig's url and security contact apply only while Voxgig is the publisher.
+function publisherInfo(model: any): { name: string, url: string, security: string } {
+  const declared = model?.main?.[KIT]?.publisher || {}
+
+  const name = declaredText(declared.name) || PUBLISHER
+  const own = PUBLISHER === name
+
+  return {
+    name,
+    url: declaredText(declared.url) || (own ? PUBLISHER_URL : ''),
+    security: declaredText(declared.security) || (own ? SECURITY_EMAIL : ''),
+  }
+}
+
+
+function isDefaultPublisher(model: any): boolean {
+  return PUBLISHER === publisherInfo(model).name
+}
+
+
+// Completes "Please report security issues ...".
+function securityContact(model: any): string {
+  const { name, url, security } = publisherInfo(model)
+  return '' !== security ? `to ${security}` :
+    `privately to ${name}` + ('' !== url ? ` (${url})` : '')
 }
 
 
@@ -300,11 +368,12 @@ function authorInfo(model: any, target?: string): { name: string, url: string }
   const declared = (null != perTarget && '' !== (perTarget.name || '')) ?
     perTarget : (model?.main?.[KIT]?.author || {})
 
-  const name = null != declared.name && '' !== declared.name ?
-    String(declared.name) : PUBLISHER
+  const publisher = publisherInfo(model)
+
+  const name = declaredText(declared.name) || publisher.name
 
-  const url = null != declared.url && '' !== declared.url ? String(declared.url) :
-    (PUBLISHER === name ? PUBLISHER_URL : '')
+  const url = declaredText(declared.url) ||
+    (publisher.name === name ? publisher.url : '')
 
   return { name, url }
 }
@@ -348,6 +417,9 @@ export {
   pkgDescription,
   nonAffiliation,
   keywords,
+  publisherInfo,
+  isDefaultPublisher,
+  securityContact,
   authorInfo,
   contributorList,
   envName,