@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/src/cmp/swift/fragment/Main.fragment.swift

@@ -1,16 +1,30 @@
 // ProjectName SDK client.
+//
+// SDK TYPES ARE MODULE-QUALIFIED IN THIS FILE (`ProjectNameSdk.VMap`, not
+// `VMap`), and only in this file. MainEntity_swift emits one accessor PER
+// ENTITY into this class body, named after the entity - `Utility()`,
+// `Spec()`, `Value()` for an API with entities of those names - and inside
+// a class body a METHOD of that name shadows the TYPE for every unqualified
+// use: `utility = Utility()` then reads as a call to the accessor, and
+// `-> Utility` as a return type that does not exist. The entity TYPE is
+// already renamed on such a collision (swiftSafeTypeName), but the accessor
+// keeps the entity's own name, which is the public API. Qualifying by
+// module - the generated module is <Name>Sdk, so `ProjectNameSdk.` lands as
+// `<Name>Sdk.` - is the one spelling a method cannot shadow. The shared
+// fixture's `utility` entity is what found this; every other swift file is
+// outside this class and unaffected.
 
 import Foundation
 
 public final class ProjectNameSDK {
   public var mode = "live"
-  private var options: VMap = VMap()
-  private let utility: Utility
+  private var options: ProjectNameSdk.VMap = ProjectNameSdk.VMap()
+  private let utility: ProjectNameSdk.Utility
   public var features: [BaseFeature] = []
-  private var rootctx: Context!
+  private var rootctx: ProjectNameSdk.Context!
 
-  public init(_ optionsIn: VMap? = nil) {
-    utility = Utility()
+  public init(_ optionsIn: ProjectNameSdk.VMap? = nil) {
+    utility = ProjectNameSdk.Utility()
 
     // The process-wide config (sdkgen rung L2): read-only on the request path,
     // so every client shares one rather than rebuilding it.
@@ -20,7 +34,7 @@ public final class ProjectNameSDK {
       "client": self,
       "utility": utility,
       "config": config,
-      "shared": VMap(),
+      "shared": ProjectNameSdk.VMap(),
     ]
     if let o = optionsIn { ctxmap["options"] = o }
 
@@ -39,7 +53,7 @@ public final class ProjectNameSDK {
     // feature installs the base mock transport and the transport features
     // (retry/cache/netsim/proxy/ratelimit) wrap whatever is current, so `test`
     // must be added before them to sit at the base of the chain.
-    let featureOpts = gp(options, "feature").asMap ?? VMap()
+    let featureOpts = gp(options, "feature").asMap ?? ProjectNameSdk.VMap()
     if let featureOrder = gpath(options, "__derived__", "featureorder").asList {
       for fnameVal in featureOrder.items {
         let fname = fnameVal.asString ?? ""
@@ -67,24 +81,24 @@ public final class ProjectNameSDK {
     utility.featureHook(rootctx, "PostConstruct")
   }
 
-  public func optionsMap() -> VMap {
-    return clone(.map(options)).asMap ?? VMap()
+  public func optionsMap() -> ProjectNameSdk.VMap {
+    return clone(.map(options)).asMap ?? ProjectNameSdk.VMap()
   }
 
-  public func getUtility() -> Utility {
-    return Utility.copy(utility)
+  public func getUtility() -> ProjectNameSdk.Utility {
+    return ProjectNameSdk.Utility.copy(utility)
   }
 
-  public func getRootCtx() -> Context {
+  public func getRootCtx() -> ProjectNameSdk.Context {
     return rootctx
   }
 
-  public func prepare(_ fetchargsIn: VMap?) throws -> VMap {
+  public func prepare(_ fetchargsIn: ProjectNameSdk.VMap?) throws -> ProjectNameSdk.VMap {
     let utility = self.utility
 
-    let fetchargs = fetchargsIn ?? VMap()
+    let fetchargs = fetchargsIn ?? ProjectNameSdk.VMap()
 
-    let ctrl = gp(fetchargs, "ctrl").asMap ?? VMap()
+    let ctrl = gp(fetchargs, "ctrl").asMap ?? ProjectNameSdk.VMap()
 
     let ctx = utility.makeContext(["opname": "prepare", "ctrl": ctrl], rootctx)
 
@@ -94,8 +108,8 @@ public final class ProjectNameSDK {
     var method = gp(fetchargs, "method").asString ?? ""
     if method == "" { method = "GET" }
 
-    let pathParams = gp(fetchargs, "params").asMap ?? VMap()
-    let query = gp(fetchargs, "query").asMap ?? VMap()
+    let pathParams = gp(fetchargs, "params").asMap ?? ProjectNameSdk.VMap()
+    let query = gp(fetchargs, "query").asMap ?? ProjectNameSdk.VMap()
 
     let headers = utility.prepareHeaders(ctx)
 
@@ -103,7 +117,7 @@ public final class ProjectNameSDK {
     let prefix = gp(options, "prefix").asString ?? ""
     let suffix = gp(options, "suffix").asString ?? ""
 
-    let specmap = VMap()
+    let specmap = ProjectNameSdk.VMap()
     specmap.entries["base"] = .string(basev)
     specmap.entries["prefix"] = .string(prefix)
     specmap.entries["suffix"] = .string(suffix)
@@ -114,7 +128,7 @@ public final class ProjectNameSDK {
     specmap.entries["headers"] = .map(headers)
     specmap.entries["body"] = gp(fetchargs, "body")
     specmap.entries["step"] = .string("start")
-    ctx.spec = Spec(specmap)
+    ctx.spec = ProjectNameSdk.Spec(specmap)
 
     // Merge user-provided headers.
     if let uhm = gp(fetchargs, "headers").asMap {
@@ -131,7 +145,7 @@ public final class ProjectNameSDK {
   // Raw endpoint access is operator-controllable, like every entity op.
   // Blocking it means denying BOTH the 'direct' and 'graphql' tokens, since
   // either one reaches the same endpoint.
-  public func direct(_ fetchargsIn: VMap?) -> VMap {
+  public func direct(_ fetchargsIn: ProjectNameSdk.VMap?) -> ProjectNameSdk.VMap {
     if !opAllowed("direct") {
       return opDenied("direct")
     }
@@ -145,9 +159,9 @@ public final class ProjectNameSDK {
     return allow.contains(op)
   }
 
-  private func opDenied(_ op: String) -> VMap {
+  private func opDenied(_ op: String) -> ProjectNameSdk.VMap {
     let allow = gpath(options, "allow", "op").asString ?? ""
-    let r = VMap()
+    let r = ProjectNameSdk.VMap()
     r.entries["ok"] = .bool(false)
     r.entries["err"] = .nat(ProjectNameError(
       op + "_allow",
@@ -160,38 +174,38 @@ public final class ProjectNameSDK {
   // its own allow.op token first. Private, rather than a flag on fetchargs:
   // a caller-supplied marker would let anyone opt straight back out of the
   // gate by passing it.
-  private func rawRequest(_ fetchargsIn: VMap?) -> VMap {
+  private func rawRequest(_ fetchargsIn: ProjectNameSdk.VMap?) -> ProjectNameSdk.VMap {
     let utility = self.utility
 
-    let fetchdef: VMap
+    let fetchdef: ProjectNameSdk.VMap
     do {
       fetchdef = try prepare(fetchargsIn)
     } catch {
-      let r = VMap()
+      let r = ProjectNameSdk.VMap()
       r.entries["ok"] = .bool(false)
       r.entries["err"] = .nat(error)
       return r
     }
 
-    let fetchargs = fetchargsIn ?? VMap()
-    let ctrl = gp(fetchargs, "ctrl").asMap ?? VMap()
+    let fetchargs = fetchargsIn ?? ProjectNameSdk.VMap()
+    let ctrl = gp(fetchargs, "ctrl").asMap ?? ProjectNameSdk.VMap()
 
     let ctx = utility.makeContext(["opname": "direct", "ctrl": ctrl], rootctx)
 
     let url = gp(fetchdef, "url").asString ?? ""
 
-    let fetched: Value
+    let fetched: ProjectNameSdk.Value
     do {
       fetched = try utility.fetcher(ctx, url, fetchdef)
     } catch {
-      let r = VMap()
+      let r = ProjectNameSdk.VMap()
       r.entries["ok"] = .bool(false)
       r.entries["err"] = .nat(error)
       return r
     }
 
     if isNil(fetched) {
-      let r = VMap()
+      let r = ProjectNameSdk.VMap()
       r.entries["ok"] = .bool(false)
       r.entries["err"] = .nat(ctx.makeError("direct_no_response", "response: undefined"))
       return r
@@ -209,12 +223,12 @@ public final class ProjectNameSDK {
       }
       let noBody = status == 204 || status == 304 || contentLength == "0"
 
-      var jsonData: Value = .noval
-      if !noBody, let jf = gp(fm, "json").asNative as? NativeCall0 {
+      var jsonData: ProjectNameSdk.Value = .noval
+      if !noBody, let jf = gp(fm, "json").asNative as? ProjectNameSdk.NativeCall0 {
         jsonData = jf()
       }
 
-      let r = VMap()
+      let r = ProjectNameSdk.VMap()
       r.entries["ok"] = .bool(status >= 200 && status < 300)
       r.entries["status"] = .int(Int64(status))
       r.entries["headers"] = headers
@@ -222,7 +236,7 @@ public final class ProjectNameSDK {
       return r
     }
 
-    let r = VMap()
+    let r = ProjectNameSdk.VMap()
     r.entries["ok"] = .bool(false)
     r.entries["err"] = .nat(ctx.makeError("direct_invalid", "invalid response type"))
     return r
@@ -240,24 +254,24 @@ public final class ProjectNameSDK {
   // NOTE: like direct, this bypasses the feature pipeline — no retry,
   // ratelimit or paging features apply.
   public func graphql(
-    _ query: String, _ variables: VMap? = nil, _ ctrl: VMap? = nil
-  ) -> VMap {
+    _ query: String, _ variables: ProjectNameSdk.VMap? = nil, _ ctrl: ProjectNameSdk.VMap? = nil
+  ) -> ProjectNameSdk.VMap {
     if !opAllowed("graphql") {
       return opDenied("graphql")
     }
 
-    let headers = VMap()
+    let headers = ProjectNameSdk.VMap()
     headers.entries["content-type"] = .string("application/json")
 
-    let body = VMap()
+    let body = ProjectNameSdk.VMap()
     body.entries["query"] = .string(query)
-    body.entries["variables"] = .map(variables ?? VMap())
+    body.entries["variables"] = .map(variables ?? ProjectNameSdk.VMap())
 
-    let fetchargs = VMap()
+    let fetchargs = ProjectNameSdk.VMap()
     fetchargs.entries["method"] = .string("POST")
     fetchargs.entries["headers"] = .map(headers)
     fetchargs.entries["body"] = .map(body)
-    fetchargs.entries["ctrl"] = .map(ctrl ?? VMap())
+    fetchargs.entries["ctrl"] = .map(ctrl ?? ProjectNameSdk.VMap())
 
     let res = rawRequest(fetchargs)
 
@@ -284,10 +298,10 @@ public final class ProjectNameSDK {
 
   // <[SLOT]>
 
-  public static func testSDK(_ testoptsIn: VMap?, _ sdkoptsIn: VMap?) -> ProjectNameSDK {
-    let sdkopts = clone(.map(sdkoptsIn ?? VMap())).asMap ?? VMap()
+  public static func testSDK(_ testoptsIn: ProjectNameSdk.VMap?, _ sdkoptsIn: ProjectNameSdk.VMap?) -> ProjectNameSDK {
+    let sdkopts = clone(.map(sdkoptsIn ?? ProjectNameSdk.VMap())).asMap ?? ProjectNameSdk.VMap()
 
-    let testopts = clone(.map(testoptsIn ?? VMap())).asMap ?? VMap()
+    let testopts = clone(.map(testoptsIn ?? ProjectNameSdk.VMap())).asMap ?? ProjectNameSdk.VMap()
     testopts.entries["active"] = .bool(true)
 
     _ = setpath(.map(sdkopts), jtp("feature", "test"), .map(testopts))

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

@@ -3,6 +3,7 @@ import * as Path from 'node:path'
 
 import {
   camelify,
+  targetFeatures,
 } from '@voxgig/sdkgen'
 
 import {
@@ -146,10 +147,31 @@ function swiftTestDir(model: any): string {
 }
 
 
+// Is the `secrets` feature ACTIVE for this target - i.e. do the three
+// vendored trees under Sources/ProjectNameSDK/feature/secrets/ ship, and
+// does Package.swift declare them?
+//
+// ONE RULE, ONE PLACE: Package_swift (the manifest's three extra targets
+// plus the SDK target's `exclude:`) and Main_swift (the Copy that ships or
+// withholds the trees) both read this, so the manifest and the tree cannot
+// disagree - a manifest naming a path that is not there fails the WHOLE
+// SwiftPM package, not just the feature, and a tree without its manifest
+// entries folds three modules' worth of colliding `Value`/`Point`/`Json`
+// declarations into the SDK module.
+//
+// `targetFeatures` is the applicability gate (helpers/applicability): the
+// feature counts only when the model activates it AND this target
+// `provides: { sekreto: true }`.
+function swiftSecretsActive(model: any, target: any): boolean {
+  return null != targetFeatures(model, target)['secrets']
+}
+
+
 export {
   clean,
   projectPath,
   swiftPascalName,
+  swiftSecretsActive,
   swiftTargetDir,
   swiftTestDir,
   swiftVarName,

package/project/.sdk/src/cmp/zig/Config_zig.ts

@@ -2,6 +2,7 @@
 import {
   Content,
   File,
+  Folder,
   cmp,
   configDefinition,
   configReprSetting,
@@ -156,14 +157,11 @@ pub fn make_feature(name: []const u8) Feature {
     // the API def does not list it. The built-in set mirrors the feature
     // templates in tm/zig/feature/ (excluding `base`, the fallback, and
     // `support`, a helper module). Any model feature not already built in is
-    // appended so bespoke features still resolve.
-    const builtinFeatures = [
-      'audit', 'cache', 'clienttrack', 'cost', 'debug', 'idempotency', 'log',
-      'metrics', 'netsim', 'paging', 'proxy', 'ratelimit', 'rbac',
-      'retry', 'streaming', 'telemetry', 'test', 'timeout',
-    ]
-
-    const featureNames: string[] = [...builtinFeatures]
+    // appended so bespoke features still resolve - and so does a GATED one
+    // (`secrets`), whose source ships with the tree but whose `@import`s name
+    // build modules that exist only when the model activates it: naming it
+    // here unconditionally would make every zig SDK fail to build.
+    const featureNames: string[] = [...BUILTIN_FEATURES]
     each(feature, (f: any) => {
       if (f.name !== 'base' && !featureNames.includes(f.name)) {
         featureNames.push(f.name)
@@ -183,6 +181,129 @@ pub fn make_feature(name: []const u8) Feature {
 })
 
 
+// The features tm/zig/feature/ ships UNGATED: every zig SDK has their source
+// and root.zig exports their types statically, so Config's factory can name
+// them whatever the model says. Shared with Main_zig, which uses the same
+// list to decide which ACTIVE features still need a root.zig export.
+const BUILTIN_FEATURES = [
+  'audit', 'cache', 'clienttrack', 'cost', 'debug', 'idempotency', 'log',
+  'metrics', 'netsim', 'paging', 'proxy', 'ratelimit', 'rbac',
+  'retry', 'streaming', 'telemetry', 'test', 'timeout',
+]
+
+
+// THE PLUGIN DEFINITIONS, as the root of the `sekretoplugins` build module:
+// feature/<name>/plugins.zig (the zig peer of Config_go's featurePlugins map
+// and of the plugins.rs index Main_rust emits).
+//
+// Upstream sekreto's contract since its registry was retired: a provider
+// kind not handed to the constructor is unknown to that Sekreto. So this
+// file IS the SDK's provider vocabulary - and in zig it is also what makes
+// the plugin trim REAL: a module root reaches only what it names, so a kind
+// missing here is neither in the vocabulary nor compiled, and a kind named
+// here whose file the trim removed is a compile error rather than a silent
+// one. That is exactly the shape upstream recommends for a lean consumer
+// (plugins/all.zig: "roots its plugins module at the one file it needs").
+//
+// It sits one level ABOVE the vendored `plugins/` directory, deliberately:
+// the vendoring guard fails any non-vendored file inside a vendored dir, and
+// a zig module root reaches its whole SUBTREE, so `plugins/<kind>.zig` is
+// within reach from here while the file itself is outside the guarded tree.
+//
+// Emitted only for a feature that is ACTIVE for this target (targetFeatures),
+// which is also exactly when build.zig declares the module that roots here -
+// an inactive model gets neither, so nothing dangles.
+const FeaturePlugins = cmp(async function FeaturePlugins(props: any) {
+  const ctx$ = props.ctx$
+  const target = props.target
+  const model: Model = ctx$.model
+
+  const feature = targetFeatures(model, target)
+
+  each(feature, (feat: any) => {
+    // `only_active: false`, the subtlety pluginExcludesFor documents: the
+    // feature object a component is handed has already been filtered, so a
+    // feature whose plugins are ALL inactive would arrive with nothing here
+    // and the module root build.zig points at would not be emitted at all.
+    const declared = getModelPath(model,
+      `main.${KIT}.feature.${feat.name}.plugin`,
+      { required: false, only_active: false }) || {}
+
+    if (0 === Object.keys(declared).length) {
+      return
+    }
+
+    // symbol -> the file (target-root-relative) that exports it.
+    const defs: Record<string, string> = {}
+
+    each(declared, (plugin: any) => {
+      // Filter on `active` HERE (Config_go's note): getting this wrong names
+      // a file the trim just removed, which is a compile error.
+      if (true !== plugin.active) return
+
+      for (const [sym, one] of Object.entries(plugin.def?.zig || {})) {
+        defs[sym] = String(one)
+      }
+    })
+
+    Folder({ name: 'feature' }, () => {
+      Folder({ name: feat.name }, () => {
+        File({ name: 'plugins.' + target.ext }, () => {
+          Content(`// The plugin definitions the model selected for the \`${feat.name}\`
+// feature (generated - see Config_zig FeaturePlugins). The ROOT of the
+// \`sekretoplugins\` build module: zig analyses only what a module root
+// reaches, so a kind this file does not name is neither in the provider
+// vocabulary nor compiled - this file IS the plugin trim.
+//
+// Upstream sekreto's contract since its registry was retired: a provider
+// kind not handed to the constructor is unknown to that Sekreto.
+
+const sekreto = @import("sekreto");
+
+// The shared HTTP round-trip the vault kinds import by relative path, and
+// the exchange's fetch of last resort (feature/${feat.name}.zig). In NO
+// plugin group, so it is always reachable from here - which is what
+// upstream's own all.zig does.
+pub const httpjson = @import("plugins/httpjson.zig");
+
+`)
+          const syms = Object.keys(defs).sort()
+
+          for (const sym of syms) {
+            // 'feature/secrets/plugins/aws.zig' -> 'plugins/aws.zig', relative
+            // to this file's directory (feature/<name>/).
+            const rel = defs[sym].replace(new RegExp('^feature/' +
+              feat.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '/'), '')
+            Content(`pub const ${sym} = @import("${rel}").${sym};
+`)
+          }
+
+          if (0 < syms.length) {
+            Content(`
+pub const SELECTED = [_]sekreto.Definition{
+`)
+            for (const sym of syms) {
+              Content(`    ${sym},
+`)
+            }
+            Content(`};
+`)
+          }
+          else {
+            Content(`// No plugin group is active: the chain can name the four built-in kinds
+// (env, memory, dotenv, file) and nothing else.
+pub const SELECTED = [_]sekreto.Definition{};
+`)
+          }
+        })
+      })
+    })
+  })
+})
+
+
 export {
-  Config
+  Config,
+  FeaturePlugins,
+  BUILTIN_FEATURES,
 }