@voxgig/sdkgen 4.9.0 → 4.11.0

package/project/.sdk/src/cmp/perl/Main_perl.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names,
   File, Content, Copy, Folder, Fragment,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -43,6 +44,10 @@ const Main = cmp(async function Main(props: any) {
   // helpers/applicability.
   const feature = targetFeatures(model, target)
 
+  // Does the secrets feature apply here and is it switched on? Both, since
+  // targetFeatures already dropped it for a target with no sekreto port.
+  const secrets = null != (feature as any).secrets
+
   Package({ target })
 
   Gitignore({})
@@ -50,7 +55,14 @@ const Main = cmp(async function Main(props: any) {
   // Copy tm/perl files with replacements
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // An ACTIVE feature's INACTIVE plugins do not ship. perl has no
+    // src/feature layout (srcfeature: false), so this blanket copy is the
+    // one place the generate-time plugin trim can act; the model's
+    // `plugin.<group>.path` entries name their files relative to THIS
+    // copy's root ('feature/secrets/plugins/Voxgig/Sekreto/Plugins/
+    // <Kind>.pm'). See helpers/featureSource.pluginExcludes, and
+    // Main_go.ts / Main_py.ts, which do the same.
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }
@@ -72,6 +84,34 @@ const Main = cmp(async function Main(props: any) {
             '/(?<indent>[ \\t]*)#[ \\t]*#(?<name>[A-Za-z0-9]+)-Hook[ \\t]*\\n?/':
               ({ name, indent }: any) =>
                 `${indent}$utility->{feature_hook}->($ctx, "${name}");\n`,
+
+            // SECRETS. The accessor is emitted only when the secrets
+            // feature applies to this target AND the model activates it -
+            // with the feature off the marker line is REMOVED, so the
+            // inactive output is byte-identical to pre-migration.
+            //
+            // The LIVE Sekreto, not a clone: sekreto holds provider and
+            // cache state, so a clone would resolve into a copy nothing
+            // else can see.
+            //
+            // There is deliberately NO resolve seam here. Unlike ts and
+            // py, this port resolves at the TRANSPORT (see
+            // feature/secrets_feature.pm), which every wire path -
+            // entity ops, direct() and graphql() - already crosses.
+            '/(?<indent>[ \\t]*)#[ \\t]*#SecretsAccessor[ \\t]*\\n?/':
+              ({ indent }: any) => !secrets ? '' :
+                `${indent}# The LIVE Sekreto instance: for arbitrary secrets and redaction.\n` +
+                `${indent}#\n` +
+                `${indent}#   $sdk->secrets->get('db.password')\n` +
+                `${indent}#   $sdk->secrets->redactall($logline)\n` +
+                `${indent}#\n` +
+                `${indent}# Never a clone: sekreto holds provider state (caches, vault\n` +
+                `${indent}# leases) that has to stay live to be worth anything.\n` +
+                `${indent}sub secrets {\n` +
+                `${indent}  my ($self) = @_;\n` +
+                `${indent}  my $f = $self->{_secrets};\n` +
+                `${indent}  return defined $f ? $f->sekreto : undef;\n` +
+                `${indent}}\n\n`,
           }
         },
 

package/project/.sdk/src/cmp/perl/Package_perl.ts

@@ -5,6 +5,7 @@ import {
   cmp,
   collectDeps,
   pkgDescription,
+  targetFeatures,
 } from '@voxgig/sdkgen'
 
 
@@ -27,6 +28,17 @@ const Package = cmp(async function Package(props: any) {
   // (e.g. "Voxgig::SDK::Solar" -> dist voxgig-sdk-solar).
   const Name = model.const.Name
 
+  // THE PERL FLOOR IS A FUNCTION OF THE FEATURE SET, not a constant.
+  //
+  // The base SDK is pure 5.018 perl. The secrets feature is not: the
+  // vendored voxgig/plugin runtime it depends on opens with
+  // `use builtin qw(is_bool)`, which is 5.36's and is the only way that
+  // port can tell `true` from `1`. Shipping 5.018 in the manifest of an
+  // SDK that cannot run on 5.018 installs cleanly and then dies at
+  // require time, so the floor moves with the feature.
+  const secrets = null != (targetFeatures(model, target) as any).secrets
+  const minperl = secrets ? '5.036' : '5.018'
+
   const deps = collectDeps(model, target.name, target.deps, ctx$.log)
   const prereq = deps
     .map((d: any) => `        '${d.name}' => '${d.version || '0'}',`)
@@ -51,7 +63,7 @@ WriteMakefile(
     ABSTRACT         => '${pkgDescription(model, target.name)}',
     AUTHOR           => 'Voxgig',
     LICENSE          => 'mit',
-    MIN_PERL_VERSION => '5.018',
+    MIN_PERL_VERSION => '${minperl}',
 ${prereq ? `    PREREQ_PM        => {\n${prereq}\n    },\n` : ''});
 `)
   })

package/project/.sdk/src/cmp/perl/fragment/Main.fragment.pm

@@ -116,6 +116,7 @@ sub get_root_ctx {
   return $self->{_rootctx};
 }
 
+# #SecretsAccessor
 sub prepare {
   my ($self, $fetchargs) = @_;
   my $utility = $self->{_utility};

package/project/.sdk/src/cmp/php/Config_php.ts

@@ -33,6 +33,77 @@ import {
 } from './utility_php'
 
 
+// PLUGIN DEFINITION REQUIRES AND THE feature_plugins ACCESSOR (the php peer
+// of cmp/rb/Config_rb.ts's rbPlugins and cmp/py/Config_py.ts's
+// pluginImports/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 config names each active
+// plugin's exported DEFINITION FUNCTION (the model's `def.php` map) and
+// hands the list to the feature.
+//
+// A METHOD rather than a constant, and this is php's own constraint: a
+// plugin definition holds CLOSURES (sekreto's Providers.php says so where
+// it declares `builtins()`), and php has no constant that can. The
+// `require_once` calls live INSIDE the method for the same reason upstream
+// puts them inside plugins.php's own accessors - a plugin file is read only
+// when a feature actually asks for its definitions.
+//
+// The `def` map is declared in the model rather than derived from filenames
+// because one file may export several definitions (sekreto's aws.php
+// exports awssecrets AND awsparams) - hence the de-duplication by path, so
+// a two-definition file yields ONE require_once. A def value is the file's
+// path under tm/php, which is this target's root and also config.php's own
+// directory, so the require is that path verbatim.
+//
+// GATED, like rb: the whole block is emitted only when an active feature
+// DECLARES a plugin catalogue for this target. An SDK that does not carry
+// the secrets feature must be byte-identical to what it was before the
+// feature existed, and an unread accessor is not a thing a simple SDK
+// should have to explain. The feature reads it through `method_exists`, so
+// its absence is not a load error.
+function phpPlugins(model: any, feature: any) {
+  const defs: Record<string, { paths: string[], syms: string[] }> = {}
+  let declared = false
+
+  each(feature, (f: any) => {
+    // `only_active: false`, and this is the whole subtlety: the feature
+    // object a component is handed has ALREADY been filtered, so asking it
+    // whether a catalogue EXISTS answers no as soon as every group is off.
+    // (Same trap helpers/featureSource documents one level down.)
+    const all = getModelPath(model, `main.${KIT}.feature.${f.name}.plugin`,
+      { required: false, only_active: false }) || {}
+
+    if (0 < Object.keys(all).length) {
+      declared = true
+    }
+
+    const paths: Record<string, true> = {}
+    const syms: string[] = []
+
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered: getting it wrong in this direction emits a
+      // require_once for a file the plugin trim just deleted - an SDK that
+      // does not load, rather than one that merely carries too much.
+      if (false === plugin.active || null == plugin.active) return
+
+      for (const [sym, one] of Object.entries(plugin.def?.php || {})) {
+        paths[String(one)] = true
+        syms.push(sym)
+      }
+    })
+
+    if (0 < syms.length) {
+      defs[f.name] = { paths: Object.keys(paths).sort(), syms: syms.sort() }
+    }
+  })
+
+  return { defs, declared }
+}
+
+
 const Config = cmp(async function Config(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -79,6 +150,39 @@ const Config = cmp(async function Config(props: any) {
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
+  const { defs: pluginDefs, declared: pluginDeclared } = phpPlugins(model, feature)
+  const pluginFeatures = Object.keys(pluginDefs).sort()
+
+  // Emitted whenever a catalogue is declared, even with every group off:
+  // the feature asks for the list unconditionally, and an SDK whose chain
+  // is all built-ins still has to be answered with an empty one.
+  const featurePluginsBlock = !pluginDeclared ? '' : `
+    /**
+     * The sekreto plugin DEFINITIONS the model selected per feature, from
+     * the files the catalogue's active \`plugin.def\` entries declare.
+     * Handed to each feature (secrets builds its Sekreto with them): a
+     * provider kind not listed here is unknown to this SDK.
+     *
+     * A method rather than a constant: a definition holds closures, and PHP
+     * has no constant that can. The requires are INSIDE it, so a plugin
+     * file is read only when a feature asks for its definitions.
+     */
+    public static function feature_plugins(string $name): array
+    {
+` + (0 === pluginFeatures.length ? '' : `        switch ($name) {
+` + pluginFeatures.map((fname: string) => `            case "${fname}":
+` + pluginDefs[fname].paths.map(
+    (one: string) => `                require_once __DIR__ . '/${one}';\n`).join('') +
+`                return [
+` + pluginDefs[fname].syms.map(
+    (sym: string) => `                    \\Voxgig\\Sekreto\\Plugins\\${sym}(),\n`).join('') +
+`                ];
+`).join('') + `        }
+
+`) + `        return [];
+    }
+`
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`<?php
@@ -248,7 +352,7 @@ configDef.entity, 3)},
     }
 
     Content(`
-
+${featurePluginsBlock}
     public static function make_feature(string $name)
     {
         require_once __DIR__ . '/features.php';

package/project/.sdk/src/cmp/php/Gitignore_php.ts

@@ -8,8 +8,10 @@ import {
 
 const Gitignore = cmp(async function Gitignore(_props: any) {
   File({ name: '.gitignore' }, () => {
-    Content(`# Composer
-vendor/
+    Content(`# Composer (the package root only: test/vendor/ is the vendored
+# omni test runner, generated output that a checkout must carry, and an
+# unanchored vendor/ silently kept it out of every commit and so out of CI)
+/vendor/
 composer.phar
 
 # PHPUnit

package/project/.sdk/src/cmp/php/Main_php.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -45,7 +46,21 @@ const Main = cmp(async function Main(props: any) {
   // Copy tm/php files with replacements
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // ANCHORED at the template root. Copy's exclude matches the
+    // SOURCE-RELATIVE path, so the old unanchored /src\// also pruned
+    // `feature/secrets/sekreto/src/` - the vendored sekreto core, whose
+    // directory depth is fixed by upstream and by the vendoring guard. The
+    // anchored form prunes the same top-level `tm/php/src/` placeholder
+    // tree (a `src` directory entry matches on the `$` arm, so the whole
+    // subtree is still pruned at the directory) and nothing else.
+    //
+    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
+    // group's declared files stay out of the tree - the model's `path`
+    // entries are target-root-relative, which is this Copy's root). With
+    // no active feature declaring a plugin catalogue it is EMPTY, so a
+    // simple SDK's output is unchanged. The FEATURE-level trim for php
+    // stays an add-time concern (vendor-tag rollout, Decision 5).
+    exclude: [/^src(\/|$)/, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }

package/project/.sdk/src/cmp/rb/Config_rb.ts

@@ -33,6 +33,74 @@ import {
 } from './utility_rb'
 
 
+// PLUGIN DEFINITION REQUIRES AND THE FEATURE_PLUGINS MAP (the ruby peer of
+// cmp/py/Config_py.ts's pluginImports/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 config requires each
+// active plugin's module and names its exported definition CONSTANT (the
+// model's `def.rb` map), handing the list to the feature through
+// FEATURE_PLUGINS.
+//
+// The `def` map is declared in the model rather than derived from filenames
+// because one module may export several definitions (sekreto's aws.rb
+// exports AWSSECRETS and AWSPARAMS) - hence the de-duplication by path, so
+// a two-definition module yields ONE require. A def value is the module's
+// path under tm/rb, which is this target's root, so the require_relative is
+// that path without its extension.
+//
+// GATED, unlike go and py: the whole block is emitted only when an active
+// feature DECLARES a plugin catalogue for this target. An SDK that does not
+// carry the secrets feature must be byte-identical to what it was before
+// the feature existed, and an unread constant is not a thing a simple SDK
+// should have to explain.
+function rbPlugins(model: any, feature: any) {
+  // path -> [constant, ...], so one require serves a two-definition module.
+  const bypath: Record<string, string[]> = {}
+  const defs: Record<string, string[]> = {}
+  let declared = false
+
+  each(feature, (f: any) => {
+    // `only_active: false`, and this is the whole subtlety: the feature
+    // object a component is handed has ALREADY been filtered, so asking it
+    // whether a catalogue EXISTS answers no as soon as every group is off.
+    // (Same trap helpers/featureSource documents one level down.)
+    const all = getModelPath(model, `main.${KIT}.feature.${f.name}.plugin`,
+      { required: false, only_active: false }) || {}
+
+    if (0 < Object.keys(all).length) {
+      declared = true
+    }
+
+    const syms: string[] = []
+
+    each(f.plugin, (plugin: any) => {
+      // Filter on `active` HERE rather than trusting the feature object to
+      // arrive filtered: getting it wrong in this direction emits a require
+      // for a module the plugin trim just deleted - an SDK that does not
+      // load, rather than one that merely carries too much.
+      if (false === plugin.active || null == plugin.active) return
+
+      for (const [sym, one] of Object.entries(plugin.def?.rb || {})) {
+        const path = String(one)
+        ; (bypath[path] = bypath[path] || []).push(sym)
+        syms.push(sym)
+      }
+    })
+
+    if (0 < syms.length) {
+      defs[f.name] = syms.sort()
+    }
+  })
+
+  const requires = Object.keys(bypath).sort().map(
+    (path: string) => `require_relative '${path.replace(/\.rb$/, '')}'`)
+
+  return { requires, defs, declared }
+}
+
+
 const Config = cmp(async function Config(props: any) {
   const ctx$ = props.ctx$
   const target = props.target
@@ -80,12 +148,34 @@ const Config = cmp(async function Config(props: any) {
   const { def: configDef, json: configJson } = configDefinition(model, target.name)
   const asData = isConfigData(configJson, configReprSetting(model))
 
+  const { requires, defs, declared } = rbPlugins(model, feature)
+
+  const pluginRequireBlock = 0 === requires.length ? '' :
+    '\n' + requires.join('\n') + '\n'
+
+  // Emitted whenever a catalogue is declared, even with every group off:
+  // the feature module reads the map unconditionally, and an SDK whose
+  // chain is all built-ins still has to answer with an empty list.
+  const featurePluginsBlock = !declared ? '' :
+    `  # The sekreto plugin DEFINITIONS the model selected per feature,
+  # required above from the modules the catalogue's active \`plugin.def\`
+  # entries declare. Handed to each feature (secrets builds its Sekreto
+  # with them): a provider kind not listed here is unknown to this SDK.
+  FEATURE_PLUGINS = {
+` +
+    Object.keys(defs).sort().map((fname: string) =>
+      `    "${fname}" => [${defs[fname].join(', ')}],\n`).join('') +
+    `  }.freeze
+
+
+`
+
   File({ name: 'config.' + target.ext }, () => {
 
     Content(`# ${model.const.Name} SDK configuration
-${asData ? "\nrequire 'json'\n" : ''}
+${asData ? "\nrequire 'json'\n" : ''}${pluginRequireBlock}
 module ${model.const.Name}Config
-  # Return the process-wide config, built once on first use. The SDK reads
+${featurePluginsBlock}  # Return the process-wide config, built once on first use. The SDK reads
   # the config on every request and never writes to it, so one instance is
   # shared by every client rather than rebuilt per client.
   #

package/project/.sdk/src/cmp/rb/EntityTypes_rb.ts

@@ -50,11 +50,21 @@ function symName(name: string): string {
 // Emit one typed value class: a YARD @!attribute block plus a keyword-init
 // Struct. Ruby's `Struct.new` rejects zero members, so an empty shape falls
 // back to a plain empty class (keeps the type name available).
+//
+// A member with an EMPTY name is dropped first. `Struct.new(:"")` raises
+// `NameError: cannot make operator ID : attrset` when the file loads, which
+// takes the whole SDK down rather than just that type -- and quoting does
+// not help, since the empty symbol is the one Ruby will not accept (`:"a-b"`
+// and `:"1x"` are both fine). A model should not carry a nameless field, so
+// upstream is where it gets fixed; this keeps one bad field from costing the
+// target everything.
 function emitStruct(
   typeName: string,
   doc: string,
-  members: Array<{ name: string, type: unknown, optional: boolean }>,
+  allmembers: Array<{ name: string, type: unknown, optional: boolean }>,
 ) {
+  const members = allmembers.filter((m) => '' !== String(m.name ?? '').trim())
+
   let block = `# ${doc}\n`
 
   members.forEach((m) => {

package/project/.sdk/src/cmp/rb/Main_rb.ts

@@ -4,6 +4,7 @@ import * as Path from 'node:path'
 import {
   cmp, each, names, cmap,
   List, File, Content, Copy, Folder, Fragment, Line, FeatureHook,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -45,7 +46,12 @@ const Main = cmp(async function Main(props: any) {
   // Copy tm/rb files with replacements
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
+    // group's declared files stay out of the tree - the model's `path`
+    // entries are target-root-relative, which is this Copy's root). The
+    // FEATURE-level trim for rb stays an add-time concern (vendor-tag
+    // rollout, Decision 5).
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
     }

package/project/.sdk/src/cmp/rust/Main_rust.ts

@@ -5,6 +5,7 @@ import {
   cmp, each,
   File, Content, Copy, Folder, Fragment,
   entityClassName,
+  pluginExcludes,
   targetFeatures,
   TEST_CONTROL_EXCLUDE
 } from '@voxgig/sdkgen'
@@ -55,7 +56,11 @@ const Main = cmp(async function Main(props: any) {
   // here exactly like the go target.
   Copy({
     from: 'tm/' + target.name,
-    exclude: [/src\//, TEST_CONTROL_EXCLUDE],
+    // pluginExcludes: the generate-time plugin trim (an INACTIVE plugin
+    // group's declared files stay out of the tree - the model's `path`
+    // entries are target-root-relative, which is this Copy's root). The
+    // FEATURE-level trim for rust stays an add-time concern, as go's does.
+    exclude: [/src\//, TEST_CONTROL_EXCLUDE, ...pluginExcludes(model)],
     replace: {
       ...props.ctx$.stdrep,
       RUSTCRATE: rustcrate,
@@ -109,6 +114,99 @@ pub mod base;
 `)
       each(feature, (feat: any) => Content(`pub mod ${feat.name};\n`))
     })
+
+    // feature/<name>/plugins.rs - a feature's PLUGIN module index.
+    //
+    // GENERATED, and it has no go/py analogue: rust compiles only the
+    // modules a parent DECLARES, and the declared set varies with the
+    // plugin trim, so a static index would either name a file the trim
+    // just deleted or leave an active kind out of the build.
+    //
+    // It sits one level ABOVE the vendored `plugins/` directory on
+    // purpose: the vendoring guard fails any non-vendored file inside a
+    // vendor dir. Nothing is lost by that - an .rs file no module
+    // declares is not compiled at all, so an inactive group's vendored
+    // file left on disk is inert whether or not the trim reached it.
+    //
+    // This is rust's replacement for go's core-emitted FeaturePlugins map
+    // (Config_go), and it is better placed: core/config.rs never has to
+    // name a feature's types.
+    each(feature, (feat: any) => {
+      // `only_active: false`, the same 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 index would not be emitted at
+      // all - leaving `pub mod plugins;` in the feature source pointing
+      // at a file that does not exist.
+      const declared = getModelPath(model,
+        `main.${KIT}.feature.${feat.name}.plugin`,
+        { required: false, only_active: false }) || {}
+
+      if (0 === Object.keys(declared).length) {
+        return
+      }
+
+      const mods = new Set<string>()
+      const syms = new Set<string>()
+
+      each(declared, (plugin: any) => {
+        // Filter on `active` HERE (Config_go's note): getting this wrong
+        // declares a module for a file the trim just removed, which is a
+        // compile error rather than a silent one.
+        if (true !== plugin.active) return
+
+        for (const [sym, one] of Object.entries(plugin.def?.rust || {})) {
+          // 'feature/secrets/plugins/aws.rs' -> the module `aws`.
+          mods.add(String(one).replace(/^.*\//, '').replace(/\.rs$/, ''))
+          syms.add(sym)
+        }
+      })
+
+      // The shared HTTP client the vendored vault kinds import
+      // (`use super::httpjson::...`) belongs to NO plugin group - trimming
+      // it with any one group would delete a file the others compile
+      // against - so it ships with the feature core and is DECLARED here
+      // only when something reaches for it. That is what keeps rustls out
+      // of a chain that is [dotenv, env] or [secretspec].
+      const NOHTTP = ['secretspec']
+      const http = Array.from(mods).some((m: string) => !NOHTTP.includes(m))
+
+      Folder({ name: feat.name }, () => {
+        File({ name: 'plugins.' + target.ext }, () => {
+          Content(`// The plugin definitions the model selected for the \`${feat.name}\`
+// feature, and the modules they live in (generated - see Main_rust).
+//
+// Upstream sekreto's contract since its registry was retired: a provider
+// kind not handed to the constructor is unknown to that Sekreto. So this
+// list IS the SDK's provider vocabulary, and a kind nobody selected is
+// neither declared nor compiled.
+
+use crate::feature::${feat.name}::plugin::catalog::Definition;
+
+`)
+          if (http) {
+            Content(`pub mod httpjson;
+`)
+          }
+          for (const m of Array.from(mods).sort()) {
+            Content(`pub mod ${m};
+`)
+          }
+
+          Content(`
+pub fn definitions() -> Vec<Definition> {
+    vec![
+`)
+          for (const sym of Array.from(syms).sort()) {
+            Content(`        ${sym}(),
+`)
+          }
+          Content(`    ]
+}
+`)
+        })
+      })
+    })
   })
 
   // entity/mod.rs — the entity module index.

package/project/.sdk/src/cmp/rust/Package_rust.ts

@@ -5,6 +5,7 @@ import {
   cmp,
   collectDeps,
   packageVersion,
+  targetFeatures,
 } from '@voxgig/sdkgen'
 
 
@@ -49,17 +50,17 @@ path = "lib.rs"
       // deps require an explicit version.
       const version = d.source === 'target' ? (d.version || '*') : d.version
       if ('dev' === (d.raw as any)?.kind) {
-        dev[d.name] = version
+        dev[d.name] = depValue(version, d.raw)
       }
       else {
-        prod[d.name] = version
+        prod[d.name] = depValue(version, d.raw)
       }
     }
 
     Content(`[dependencies]
 `)
-    for (const [name, version] of Object.entries(prod)) {
-      Content(`${name} = "${version}"
+    for (const [name, value] of Object.entries(prod)) {
+      Content(`${name} = ${value}
 `)
     }
 
@@ -67,15 +68,80 @@ path = "lib.rs"
       Content(`
 [dev-dependencies]
 `)
-      for (const [name, version] of Object.entries(dev)) {
-        Content(`${name} = "${version}"
+      for (const [name, value] of Object.entries(dev)) {
+        Content(`${name} = ${value}
 `)
       }
     }
+
+    // [[test]] stanzas for the feature suites.
+    //
+    // cargo auto-discovers `tests/*.rs` and `tests/<dir>/main.rs`, but NOT
+    // `tests/<dir>/<dir>/main.rs` - and the two-level path is not
+    // negotiable: a feature's tests must live inside a `feature/`
+    // container so `target add` trims them WITH the feature
+    // (helpers/featureSource), exactly as go's tm/go/test/feature/secrets/
+    // and py's tm/py/test/feature/secrets/ do. A one-level
+    // tests/secrets/main.rs would auto-discover and then be left behind in
+    // a project that does not select the feature, carrying a suite that
+    // cannot compile.
+    //
+    // So the suite is DECLARED, and only for a feature that both applies
+    // to this target and is active in the model - which is also exactly
+    // when `target add` kept its directory.
+    const suites = Object.keys(targetFeatures(model, target))
+      .filter((name: string) => null != FEATURE_TESTS[name])
+      .sort()
+
+    for (const name of suites) {
+      Content(`
+[[test]]
+name = "${name}_feature"
+path = "${FEATURE_TESTS[name]}"
+`)
+    }
   })
 })
 
 
+// Which features ship a rust integration-test suite, and where its crate
+// root is. A map rather than a convention because the file has to EXIST:
+// cargo fails the whole manifest on a `[[test]]` path it cannot find, so
+// this may only name suites the templates actually carry.
+const FEATURE_TESTS: Record<string, string> = {
+  secrets: 'tests/feature/secrets/main.rs',
+}
+
+
+// One Cargo dependency's value: the bare version string, or the TABLE form
+// when the model asks for anything more.
+//
+// `default: false` and `features: [...]` are not decoration. The secrets
+// feature's vendored HTTP helper speaks rustls, and `rustls = "0.23"` with
+// DEFAULT features pulls aws-lc-rs/aws-lc-sys and a cmake C build, while
+// the ring feature set is what the target's existing `ureq` dep already
+// compiles. Without the table form, turning on one feature would add a
+// native toolchain requirement to every SDK that selected it.
+function depValue(version: string, raw: any): string {
+  const features: string[] = Array.isArray(raw?.features) ? raw.features : []
+  const nodefault = false === raw?.default
+
+  if (0 === features.length && !nodefault) {
+    return `"${version}"`
+  }
+
+  const parts = [`version = "${version}"`]
+  if (nodefault) {
+    parts.push('default-features = false')
+  }
+  if (0 < features.length) {
+    parts.push('features = [' + features.map((f) => `"${f}"`).join(', ') + ']')
+  }
+
+  return '{ ' + parts.join(', ') + ' }'
+}
+
+
 export {
   Package
 }