@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/src/cmp/scala/Config_scala.ts

@@ -45,6 +45,43 @@ const Config = cmp(async function Config(props: any) {
 
   const headers = getModelPath(model, `main.${KIT}.config.headers`) || {}
 
+  // PLUGIN DEFINITIONS, per feature (the scala peer of Config_go's
+  // featurePlugins map and Config_ts's pluginDefs).
+  //
+  // Since sekreto retired its import-time registry, provider kinds are
+  // voxgig/plugin definitions: a kind the caller did not pass in via
+  // `plugins` is unknown to that Sekreto. So the config names each active
+  // plugin's exported Definition and hands the list to the feature.
+  //
+  // The scala symbols are fully-qualified top-level `val`s
+  // (`com.voxgig.sekreto.plugins.hashicorp`), so unlike go there is no
+  // import to emit - and an inactive group therefore leaves no reference at
+  // all behind for the generate-time plugin trim to dangle.
+  //
+  // Typed List[Any], never List[Definition]: core must not name a vendored
+  // type, or a tree carrying the feature source without the feature selected
+  // would fail to compile.
+  const featurePlugins: Record<string, string[]> = {}
+  each(feature, (f: any) => {
+    const syms: string[] = []
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered (the trap Config_ts documents): naming a symbol the
+      // trim just deleted is a build break, not a warning.
+      if (false === plugin.active || null == plugin.active) return
+      for (const sym of Object.keys(plugin.def?.scala || {})) {
+        syms.push(sym)
+      }
+    })
+    if (0 < syms.length) {
+      featurePlugins[f.name] = syms.sort()
+    }
+  })
+
+  const featurePluginsBlock =
+    Object.keys(featurePlugins).sort().map((fname: string) =>
+      `    case "${fname}" => List(${featurePlugins[fname].join(', ')})\n`).join('')
+
   const authActive = isAuthActive(model)
   const authPrefix = resolveAuthPrefix(model)
 
@@ -114,6 +151,13 @@ object Config {
 
   def sharedConfig(): JMap[String, Object] = sharedConfigVal
 
+  // The plugin definitions the model selected per feature, as List[Any] so a
+  // feature consumes them without core naming a vendored type. Empty when no
+  // active feature declares active plugin groups for this target.
+  def featurePlugins(name: String): List[Any] = name match {
+${featurePluginsBlock}    case _ => Nil
+  }
+
   def makeFeature(name: String): Feature = name match {
 `)
 

package/project/.sdk/src/cmp/scala/Main_scala.ts

@@ -5,6 +5,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
   targetFeatures,
+  pluginExcludes,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
 
@@ -43,6 +44,48 @@ const Main = cmp(async function Main(props: any) {
   // The Scala package root for every runtime piece (like GOMODULE for go).
   const scalapackage = scalaPackage(model)
 
+  // THE PLUGIN TRIM, over the WHOLE model rather than its active half.
+  //
+  // pluginExcludes(model) walks only the model's ACTIVE features
+  // (helpers/featureSource), which is right for a target whose feature trim
+  // is on: an inactive feature's whole tree is already gone at `target add`,
+  // so it has no plugin files left to exclude. Scala's feature trim is OFF
+  // (see the Copy below), so the opposite holds - an inactive feature's tree
+  // is all still here, and its plugins are the part of it that costs the
+  // most. Before this, a scala SDK whose model never mentioned `secrets`
+  // shipped and compiled all nine vendored provider clients: the one trim
+  // the target has walked straight past the feature that owns them.
+  //
+  // EVERY declared group of an inactive feature goes, not just the groups
+  // marked inactive. A feature that is off has no active plugins whatever
+  // its `plugin` map says - `main: kit: feature: secrets: { active: false
+  // plugin: vault: active: true }` selects nothing, because targetFeatures
+  // drops the feature before Config ever reads a group - so shipping vault's
+  // files for it would leave a provider client in the tree that nothing in
+  // the SDK can reach. That is why this reads the declared paths directly
+  // rather than reusing pluginExcludesFor, whose rule (exclude the groups
+  // marked `active: false`) is the right one only for a LIVE feature.
+  //
+  // Rooting matches pluginExcludes': scala's declared paths are
+  // target-root-relative, which is this Copy's root, and the other targets'
+  // paths in the same list cannot match anything in a scala tree.
+  const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const allfeature = getModelPath(model, `main.${KIT}.feature`,
+    { required: false, only_active: false }) || {}
+  const inactivePluginExcludes: RegExp[] = []
+  for (const fname of Object.keys(allfeature)) {
+    if (null != (feature as any)[fname]) continue
+    const groups = getModelPath(model, `main.${KIT}.feature.${fname}.plugin`,
+      { required: false, only_active: false }) || {}
+    for (const gname of Object.keys(groups)) {
+      for (const one of (groups[gname].path || [])) {
+        const pat = esc(String(one))
+        inactivePluginExcludes.push(new RegExp('(^|/)' +
+          pat.replace(/\\\/$/, '') + (/\/$/.test(String(one)) ? '/' : '$')))
+      }
+    }
+  }
+
   Package({ target })
 
   Gitignore({})
@@ -52,7 +95,31 @@ const Main = cmp(async function Main(props: any) {
   // ProjectName carries the SDK name into vendored template strings.
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // The generate-time plugin trim, in both halves: pluginExcludes for an
+    // ACTIVE feature's inactive groups, inactivePluginExcludes (above) for
+    // the groups of a feature that is itself off. An inactive group's
+    // declared files stay out of the tree - the model's `path` entries are
+    // target-root-relative, which is this Copy's root.
+    //
+    // Scala's FEATURE-level trim is off (model/target/scala.aon `feature: {
+    // trim: false }`, because the cross-feature tests are fused into one
+    // sdktest/SdkTestMain.scala, which constructs fifteen feature classes by
+    // name), so this is the ONLY trim the target has, and what it does NOT
+    // reach is worth stating rather than leaving to be discovered: every
+    // feature's own source ships to every scala SDK whatever the model says,
+    // secrets included, so a secrets-off SDK still carries SecretsFeature,
+    // the vendored sekreto and voxgig/plugin cores, and the two UNGROUPED
+    // plugin files (plugins/Sigv4.scala's HMAC-SHA256 signer and
+    // plugins/Httpjson.scala's fetch + ProcessBuilder helpers, which belong
+    // to no group because four and eight kinds respectively compile against
+    // them). What it DOES reach is the nine provider clients, and they are
+    // the bulk: measured on a feature-off SDK, 26 files rather than 35.
+    exclude: [
+      /src\//,
+      TEST_CONTROL_EXCLUDE,
+      ...pluginExcludes(model),
+      ...inactivePluginExcludes,
+    ],
     replace: {
       ...props.ctx$.stdrep,
       ProjectName: model.const.Name,

package/project/.sdk/src/cmp/swift/Config_swift.ts

@@ -44,13 +44,64 @@ const Config = cmp(async function Config(props: any) {
   // matches the token-replaced runtime.
   const configJson = json.replace(/ProjectName/g, model.const.Name)
 
+  // PLUGIN DEFINITIONS AND THE featurePlugins MAP (the swift peer of
+  // Config_go's featurePlugins / Config_ts's pluginDefs).
+  //
+  // Upstream sekreto replaced its self-registration registry with
+  // voxgig/plugin definitions: a provider kind the caller did not pass in
+  // via `plugins:` is unknown to that Sekreto. So the config names each
+  // active plugin's exported Definition BY SYMBOL (the model's per-target
+  // `def.swift` map - `hashicorp`, a top-level `let` in the vendored
+  // SekretoPlugins module) and hands the list to the feature through
+  // SdkConfig.featurePlugins.
+  //
+  // Typed `[String: [Any]]`, as go types it `[]any`, so Config never has to
+  // name `Definition` - and so needs `import SekretoPlugins` only when a
+  // definition is actually listed. The feature reads the list back and
+  // downcasts.
+  //
+  // The ACCESSOR IS EMITTED UNCONDITIONALLY (empty map when nothing is
+  // selected). Its caller, feature/SecretsFeature.swift, ships whenever the
+  // feature is active, and java gated the accessor on "a feature declares a
+  // plugin block" - which a project that never selected secrets does not
+  // have - and shipped an SDK that did not compile (.handover-briefs/
+  // fixb-java.md). One rule: what a template may reference, Config always
+  // declares.
+  const featurePlugins: Record<string, string[]> = {}
+  each(feature, (f: any) => {
+    const syms: string[] = []
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered (see Config_ts.pluginImports: getting this wrong
+      // names a definition the trim just deleted, and swiftc fails the
+      // whole module on the unresolved symbol).
+      if (false === plugin.active || null == plugin.active) return
+      for (const sym of Object.keys(plugin.def?.swift || {})) {
+        syms.push(sym)
+      }
+    })
+    if (0 < syms.length) {
+      featurePlugins[f.name] = syms.sort()
+    }
+  })
+
+  const pluginImport = 0 === Object.keys(featurePlugins).length ? '' :
+    '\nimport SekretoPlugins\n'
+
+  const featurePluginsBlock = 0 === Object.keys(featurePlugins).length ?
+    '  private static let featurePluginsVal: [String: [Any]] = [:]\n' :
+    '  private static let featurePluginsVal: [String: [Any]] = [\n' +
+    Object.keys(featurePlugins).sort().map((fname: string) =>
+      `    "${fname}": [${featurePlugins[fname].join(', ')}],\n`).join('') +
+    '  ]\n'
+
   File({ name: 'Config.' + target.ext }, () => {
 
     Content(`// ${model.const.Name} SDK - generated model configuration and feature
 // factory. GENERATED from the API model - do not edit by hand.
 
 import Foundation
-
+${pluginImport}
 public enum SdkConfig {
   public static func makeConfig() -> VMap {
     let json = #"""
@@ -91,6 +142,16 @@ ${configJson}
     Content(`    default: return BaseFeature()
     }
   }
+
+  // The plugin definitions the model selected per feature, as [Any] so a
+  // feature can consume them without core naming the plugin module's
+  // types. Empty when no active feature declares active plugin groups for
+  // this target.
+${featurePluginsBlock}
+  // featurePlugins is the definitions list for one feature's chain.
+  public static func featurePlugins(_ name: String) -> [Any] {
+    return featurePluginsVal[name] ?? []
+  }
 }
 `)
   })

package/project/.sdk/src/cmp/swift/Main_swift.ts

@@ -1,11 +1,12 @@
 
 import * as Path from 'node:path'
 
-import { swiftTargetDir, swiftTestDir } from './utility_swift'
+import { swiftSecretsActive, swiftTargetDir, swiftTestDir } from './utility_swift'
 
 import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
+  pluginExcludes,
 } from '@voxgig/sdkgen'
 
 
@@ -36,6 +37,28 @@ const Main = cmp(async function Main(props: any) {
 
   const entity: ModelEntity = getModelPath(model, `main.${KIT}.entity`)
 
+  // THE SECRETS TRIM, at generate time, and swift NEEDS it where go, py and
+  // dart leave the feature-level trim to `target add` (vendor-tag rollout,
+  // Decision 5). DELIBERATE DIVERGENCE, and the reason is the build: the
+  // feature's three vendored trees are separate SwiftPM MODULES that
+  // Package_swift declares only when the feature is active (see the note
+  // there). With the feature off, a tree still in Sources/<Name>Sdk/ would
+  // be folded into the SDK target and fail it on five redeclarations, and
+  // feature/SecretsFeature.swift would fail on `import Sekreto` naming a
+  // module the manifest never declared. Every other swift feature is a
+  // single file the SDK module compiles regardless, so it needs no such
+  // exclude. Keyed on the SAME predicate the manifest uses, so the two
+  // cannot disagree. The gated suite under Tests/.../feature/secrets/ goes
+  // with it: it imports Sekreto too.
+  const secrets = swiftSecretsActive(model, target)
+  const secretsSourceExcludes: RegExp[] = secrets ? [] : [
+    /(^|\/)feature\/SecretsFeature\.swift$/,
+    /(^|\/)feature\/secrets\//,
+  ]
+  const secretsTestExcludes: RegExp[] = secrets ? [] : [
+    /(^|\/)feature\/secrets\//,
+  ]
+
   Package({ target })
 
   Gitignore({})
@@ -66,6 +89,16 @@ const Main = cmp(async function Main(props: any) {
     Copy({
       from: 'tm/' + target.name + '/Sources/ProjectNameSDK',
       to: swiftTargetDir(model),
+      // pluginExcludes: the generate-time plugin trim (an ACTIVE feature's
+      // INACTIVE plugin group's declared files stay out of the tree). The
+      // model's swift `path` entries are relative to THIS Copy's root
+      // (`feature/secrets/plugins/Aws.swift`, not `Sources/ProjectNameSDK/
+      // ...`), as py's are to its pkg copy - helpers/featureSource documents
+      // that getting the root wrong makes the trim a silent no-op. No
+      // verbatim carve-out is needed for the vendored trees: none of the
+      // upstream swift files carries a ProjectName/PROJECTENV token, so the
+      // blanket replace is inert over them.
+      exclude: [...secretsSourceExcludes, ...pluginExcludes(model)],
       replace: {
         ...props.ctx$.stdrep,
         ProjectName: model.const.Name,
@@ -77,6 +110,7 @@ const Main = cmp(async function Main(props: any) {
     Copy({
       from: 'tm/' + target.name + '/Tests/ProjectNameSDKTests',
       to: swiftTestDir(model),
+      exclude: secretsTestExcludes,
       replace: {
         ...props.ctx$.stdrep,
         ProjectName: model.const.Name,

package/project/.sdk/src/cmp/swift/Package_swift.ts

@@ -1,5 +1,4 @@
-
-import { swiftTargetDir, swiftTestDir } from './utility_swift'
+import { swiftSecretsActive, swiftTargetDir, swiftTestDir } from './utility_swift'
 
 import {
   Content,
@@ -53,6 +52,34 @@ import type {
 // declared as a .testTarget rather than a .target so `swift build` - a
 // consumer's library build - never compiles the test engine; `swift test`
 // builds it and the suite target depends on it.
+//
+// THE SECRETS FEATURE ADDS THREE MORE MODULES, and this is the same
+// precedent, load-bearing rather than tidy. The vendored @voxgig/plugin
+// host, the @voxgig/sekreto core and its plugins live under
+// Sources/<Name>Sdk/feature/secrets/{plugin,sekreto,plugins} and are
+// compiled as VoxgigPlugin, Sekreto and SekretoPlugins - upstream's own
+// three-module boundary (sekreto's swift Makefile builds exactly these). A
+// flat layout collides on five names: plugin's `Value` and `Point` against
+// the SDK's, sekreto's `Json` against plugin's, and `dropsuffix`/`getenv`,
+// which sekreto declares in BOTH src/ and plugins/ because upstream never
+// compiles them as one module. So, when the feature is active for this
+// target:
+//
+//   - three `.target`s are declared over the three directories;
+//   - the SDK target gains them as dependencies and `exclude: ["feature/
+//     secrets"]`, so SwiftPM does not ALSO fold the files into the SDK
+//     module (`exclude:` must come AFTER `path:` in the argument list, or
+//     the manifest itself fails to compile);
+//   - the library product vends all four, because `SecretsFeature.sekreto()`
+//     is public API returning a `Sekreto`, and a downstream package may only
+//     `import Sekreto` if the product exposes it;
+//   - the test target depends on Sekreto and VoxgigPlugin as well, since
+//     the gated suite builds providers against Sekreto's `Provider`
+//     protocol and reads the selected `Definition`s' kinds back.
+//
+// Keyed on swiftSecretsActive - the SAME predicate Main_swift's Copy uses
+// to ship or withhold the trees - so the manifest and the tree agree by
+// construction (a manifest naming a missing path fails the whole package).
 const Package = cmp(async function Package(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -79,13 +106,49 @@ const Package = cmp(async function Package(props: any) {
       `        .package(url: "${d.url}", from: "${d.from}"),\n`).join('') +
     '    ],'
 
-  const targetdeps = 0 === deps.length ? '' :
+  const secrets = swiftSecretsActive(model, target)
+  const srcdir = `Sources/${swiftTargetDir(model)}`
+
+  // The SDK target's dependency list: declared package products, then the
+  // three vendored secrets modules when the feature is active.
+  const sdkdeps: string[] = deps.map((d) =>
+    `.product(name: "${d.product}", package: "${d.identity}")`)
+  if (secrets) {
+    sdkdeps.push('"Sekreto"', '"SekretoPlugins"', '"VoxgigPlugin"')
+  }
+
+  const targetdeps = 0 === sdkdeps.length ? '' :
     '\n            dependencies: [\n' +
-    deps.map((d) =>
-      `                .product(name: "${d.product}", package: "${d.identity}"),\n`)
-      .join('') +
+    sdkdeps.map((d) => `                ${d},\n`).join('') +
     '            ],'
 
+  // `exclude:` AFTER `path:` - SwiftPM's argument order, not a style choice.
+  const sdkpath = secrets
+    ? `\n            path: "${srcdir}",\n            exclude: ["feature/secrets"]),`
+    : `\n            path: "${srcdir}"),`
+
+  const secretsTargets = !secrets ? '' :
+    `        .target(
+            name: "VoxgigPlugin",
+            path: "${srcdir}/feature/secrets/plugin"),
+        .target(
+            name: "Sekreto",
+            dependencies: ["VoxgigPlugin"],
+            path: "${srcdir}/feature/secrets/sekreto"),
+        .target(
+            name: "SekretoPlugins",
+            dependencies: ["Sekreto", "VoxgigPlugin"],
+            path: "${srcdir}/feature/secrets/plugins"),
+`
+
+  const products = secrets
+    ? `["${Name}Sdk", "Sekreto", "SekretoPlugins", "VoxgigPlugin"]`
+    : `["${Name}Sdk"]`
+
+  const testdeps = secrets
+    ? `["${Name}Sdk", "Omni", "Sekreto", "VoxgigPlugin"]`
+    : `["${Name}Sdk", "Omni"]`
+
   File({ name: 'Package.swift' }, () => {
     Content(`// swift-tools-version:5.9
 //
@@ -97,19 +160,26 @@ import PackageDescription
 
 let package = Package(
     name: "${Name}Sdk",
+    // The deployment floor. Without it SwiftPM assumes the oldest macOS the
+    // toolchain still targets, and the SDK's AsyncStream-based streaming
+    // (EntityBase) fails to compile on macOS with "'AsyncStream' is only
+    // available in macOS 10.15 or newer" - linux has no such floor, which
+    // is why the generator's own linux runs never saw it. Found by the
+    // secrets lane, the first lane to build a full generated swift SDK on
+    // the macos CI leg.
+    platforms: [.macOS(.v10_15)],
     products: [
-        .library(name: "${Name}Sdk", targets: ["${Name}Sdk"]),
+        .library(name: "${Name}Sdk", targets: ${products}),
     ],${pkgdeps}
     targets: [
-        .target(
-            name: "${Name}Sdk",${targetdeps}
-            path: "Sources/${swiftTargetDir(model)}"),
+${secretsTargets}        .target(
+            name: "${Name}Sdk",${targetdeps}${sdkpath}
         .testTarget(
             name: "Omni",
             path: "Tests/vendor/omni"),
         .testTarget(
             name: "${Name}SdkTests",
-            dependencies: ["${Name}Sdk", "Omni"],
+            dependencies: ${testdeps},
             path: "Tests/${swiftTestDir(model)}"),
     ]
 )