hecks 3.6.0 → 3.9.0

data/lib/hecks/projections/site/site_host/dockerfile.rb

@@ -52,7 +52,7 @@ module Hecks
 
             COPY deploy-aws/boot.mjs ./
             # RDS enforces TLS; boot.mjs verifies against Amazon's CA bundle.
-            ADD https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem ./rds-global-bundle.pem
+            ADD --chmod=0644 https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem ./rds-global-bundle.pem
 
             # boot.mjs sits outside the Next app, so `next build` does not trace its import of the AWS SDK.
             COPY --from=build /app/node_modules/@aws-sdk ./node_modules/@aws-sdk

data/lib/hecks/projections/site/site_host/templates.rb

@@ -71,9 +71,13 @@ module Hecks
 
             const client = new SecretsManagerClient({});
 
-            async function secretField(arn, field) {
+            async function secretJson(arn) {
               const { SecretString } = await client.send(new GetSecretValueCommand({ SecretId: arn }));
-              const value = JSON.parse(SecretString)[field];
+              return JSON.parse(SecretString);
+            }
+
+            async function secretField(arn, field) {
+              const value = (await secretJson(arn))[field];
               if (!value) throw new Error(`secret ${arn} has no "${field}" field`);
               return value;
             }
@@ -81,12 +85,16 @@ module Hecks
             if (process.env.DB_SECRET_ARN) {
               const { DB_HOST, DB_NAME } = process.env;
               if (!DB_HOST || !DB_NAME) throw new Error("DB_HOST and DB_NAME are required when DB_SECRET_ARN is set");
-              const password = await secretField(process.env.DB_SECRET_ARN, "password");
+              // The user and port come from the secret: RDS's master secret says postgres, and a client that shares
+              // an instance with others has its own role. A secret without them is read as postgres on 5432.
+              const { username = "postgres", password, port = 5432 } = await secretJson(process.env.DB_SECRET_ARN);
+              if (!password) throw new Error(`secret ${process.env.DB_SECRET_ARN} has no "password" field`);
               // The password goes through encodeURIComponent: the generated one can hold characters (@ / #)
               // that would otherwise split the URL. RDS enforces TLS; verify against Amazon's CA bundle,
               // which the image holds beside this file.
               const ssl = "sslmode=verify-full&sslrootcert=" + new URL("./rds-global-bundle.pem", import.meta.url).pathname;
-              process.env.DATABASE_URL = `postgres://postgres:${encodeURIComponent(password)}@${DB_HOST}:5432/${DB_NAME}?${ssl}`;
+              process.env.DATABASE_URL =
+                `postgres://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${DB_HOST}:${port}/${DB_NAME}?${ssl}`;
             } else if (!process.env.DATABASE_URL) {
               throw new Error("either DB_SECRET_ARN (+ DB_HOST/DB_NAME) or DATABASE_URL is required");
             }

data/lib/hecks/projections.rb

@@ -23,6 +23,8 @@ require_relative "projections/deploy/shared"
 require_relative "projections/deploy/lambda"
 require_relative "projections/deploy/fargate"
 require_relative "projections/deploy/box"
+require_relative "projections/deploy/shared_database_instance"
+require_relative "projections/deploy/vercel"
 require_relative "projections/deploy/smoke"
 require_relative "projections/deploy/template_diff"
 require_relative "projections/site/routes_ts"

data/lib/hecks/quality_control/adapters/github_checks.rb

@@ -14,6 +14,10 @@ module Hecks
       # Check-run conclusions that count as green; `skipped` covers path-filtered workflows.
       PASSING = %w[success neutral skipped].freeze
 
+      # The GitHub Actions app. A promotion counts only the checks it reported: a check of the same
+      # name posted by another app, a token or a person certifies nothing.
+      GITHUB_ACTIONS_APP_ID = 15_368
+
       # A commit sha as GitHub accepts it in an API path.
       SHA_PATTERN = /\A[0-9a-fA-F]{7,40}\z/
 
@@ -38,7 +42,8 @@ module Hecks
 
       # Where each named check stands against a commit, for a caller that must tell a check that is
       # still running from one that failed (`run` raises for both). A name that reported more than
-      # once (a re-run) stands as its most recent report.
+      # once (a re-run) stands as its most recent report. Only reports of the GitHub Actions app
+      # count; a name reported by any other app stands as `:missing`.
       #
       # @param commit [Hash, String] a materialized value object (`{value: sha}`) or a bare sha
       # @param names [Array<String>] the checks to look up
@@ -46,13 +51,15 @@ module Hecks
       #   not completed) or `:missing` (not reported at all)
       # @raise [RuntimeError] when the sha is malformed or `gh` is missing or fails
       def states(commit:, names:)
-        reported = check_runs(valid_sha(commit)).group_by { |run| run["name"] }
+        reported = check_runs(valid_sha(commit)).select { |run| actions?(run) }.group_by { |run| run["name"] }
         latest = reported.transform_values { |runs| runs.max_by { |run| run["id"].to_i } }
         names.to_h { |name| [name, state_of(latest[name])] }
       end
 
       private
 
+      def actions?(run) = run.dig("app", "id") == GITHUB_ACTIONS_APP_ID
+
       def valid_sha(commit)
         sha = sha_of(commit)
         raise "not a commit sha: #{sha.inspect}" unless sha.match?(SHA_PATTERN)

data/lib/hecks/quality_control/cli/qa_sweep/dials.rb

@@ -41,6 +41,7 @@ module Hecks
           @guided_generation = dial(:GUIDED_GENERATION, false)
           @corpus_splice_probability = dial(:CORPUS_SPLICE_PROBABILITY, 0.5)
           @favor_rare_verbs = dial(:FAVOR_RARE_VERBS, 3)
+          @runtime_coverage_feedback = dial(:RUNTIME_COVERAGE_FEEDBACK, false)
         end
 
         def read_limit_dials

data/lib/hecks/quality_control/cli/qa_sweep/seed_loop.rb

@@ -57,8 +57,8 @@ module Hecks
         # @return [Hash, nil] the seed's result with its surprised checks, or nil when every
         #   check held
         def run_seed(seed)
-          result = run_one_seed(@mode, seed)
-          @campaign.record(seed, result[:plan], result[:trace]) if @campaign && result[:trace]
+          result, runtime = measured_seed(seed)
+          @campaign.record(seed, result[:plan], result[:trace], runtime: runtime) if @campaign && result[:trace]
 
           surprised = log_seed_checks(result)
           if surprised.empty?
@@ -70,6 +70,14 @@ module Hecks
           result.merge(seed: seed, checks: surprised)
         end
 
+        # The seed's result, and the runtime lines and branches it reached when the dial asks for
+        # that feedback; nil otherwise, so a campaign falls back to tuples alone.
+        def measured_seed(seed)
+          return [run_one_seed(@mode, seed), nil] unless @campaign && @runtime_coverage_feedback
+
+          Hecks::Fuzzing::RuntimeCoverage.measure { run_one_seed(@mode, seed) }
+        end
+
         def check_modes(checks)
           checks.map { |c| c[:mode] }.join(", ")
         end

data/lib/hecks/runtime/value/validation.rb

@@ -88,8 +88,8 @@ module Hecks
         def normalize_composite_field(aggregate, attribute, fields)
           # A list member hydrates the same as a top-level list, so a value
           # read back from the store matches the shape a live dispatch wrote.
-          # Load door only — an input list member is left as offered.
-          return hydrate_stored_list(aggregate, attribute, fields) if attribute.list?
+          # An input list member is validated as offered and left as offered.
+          return normalize_list(aggregate, attribute, fields) if attribute.list?
 
           raw = fields[attribute.name]
           return if raw.nil? || raw.is_a?(self)
@@ -103,15 +103,46 @@ module Hecks
           fields[attribute.name] = nested_fields
         end
 
+        def normalize_list(aggregate, attribute, fields)
+          return hydrate_stored_list(aggregate, attribute, fields) if trusting_stored_state?
+
+          validate_input_list(aggregate, attribute, fields)
+        end
+
+        # Runs each value-object member of an input list through the same door a nested single
+        # value goes through, so a member's own invariants and nested lists refuse on dispatch
+        # exactly as they do when the list sits directly on a command. The members stay as offered.
+        def validate_input_list(aggregate, attribute, fields)
+          nested = value_object_for(aggregate, attribute.type)
+          return unless nested
+
+          Array(fields[attribute.name]).each do |member|
+            next unless member.is_a?(Hash)
+
+            member_fields = apply_defaults(nested, fields_for(nested, attribute.name, member))
+            validate!(nested, normalize_composite_fields(aggregate, nested, member_fields))
+          end
+        end
+
         def hydrate_stored_list(aggregate, attribute, fields)
           return unless trusting_stored_state?
 
           fields[attribute.name] = for_attribute(aggregate, attribute, fields[attribute.name])
         end
 
+        # An optional attribute the caller left out reads as nil in an invariant, so a rule can
+        # ask `x.nil?` or `x.set?` of it instead of failing to resolve a key that was never sent.
+        def with_absent_optionals(value_object, fields)
+          absent = value_object.attributes.select { |attribute| attribute.optional? && !fields.key?(attribute.name) }
+          return fields if absent.empty?
+
+          absent.to_h { |attribute| [attribute.name, nil] }.merge(fields)
+        end
+
         def check_invariants(value_object, fields)
+          known = with_absent_optionals(value_object, fields)
           value_object.invariants.each do |invariant|
-            next if Bluebook::Expression::Evaluator.call_rule(invariant, fields)
+            next if Bluebook::Expression::Evaluator.call_rule(invariant, known)
 
             raise InvariantViolation,
                   RefusalWording.render_site("InvariantViolation", "value_object_invariant",

data/lib/hecks/rust_build/native_build.rb

@@ -12,6 +12,9 @@ module Hecks
     # so a built binary is cached per `[rust_dir, feature, sources]`, where `sources` is a digest of
     # the workspace's Rust sources and manifests. Regenerating the domain changes the digest, so the
     # next call rebuilds instead of answering with a stale binary or a stale failure.
+    #
+    # A binary already pinned and newer than every source is used as it is, so binaries restored
+    # from a cache of an earlier run are not built again.
     module NativeBuild
       # Raised when a declared feature fails to build; nil is reserved for "feature not declared".
       class BuildFailed < StandardError; end
@@ -94,12 +97,37 @@ module Hecks
 
         File.open(lock_path, File::CREAT | File::RDWR) do |lock|
           lock.flock(File::LOCK_EX)
+          pinned = pinned_path(rust_dir, domain_feature)
+          next pinned if pinned_fresh?(pinned, rust_dir)
+
           command = ["cargo", "build", "--no-default-features", "--features", domain_feature]
           cargo(command, rust_dir, domain_feature)
           pin(rust_dir, domain_feature, command)
         end
       end
 
+      def pinned_path(rust_dir, domain_feature)
+        File.join(rust_dir, "target", "debug", "rust-#{domain_feature}")
+      end
+
+      # A binary pinned ahead of time, by an earlier run whose build was restored from a cache, is
+      # current when no source is newer than it: the rule `make` applies to any target.
+      #
+      # @return [Boolean] whether `pinned` exists and every source predates it
+      def pinned_fresh?(pinned, rust_dir)
+        return false unless File.executable?(pinned)
+
+        built = File.mtime(pinned)
+        source_files(rust_dir).none? { |path| File.mtime(path) > built }
+      end
+
+      # @return [Array<String>] every `.rs` and `.toml` file and `Cargo.lock` outside `target/`
+      def source_files(rust_dir)
+        paths = Dir.glob(File.join(rust_dir, "**", "*.{rs,toml}"), File::FNM_DOTMATCH)
+        paths << File.join(rust_dir, "Cargo.lock")
+        paths.select { |path| File.file?(path) && !path.delete_prefix("#{rust_dir}/").start_with?("target/") }
+      end
+
       def cargo(command, rust_dir, domain_feature)
         _stdout, stderr, status = Open3.capture3(*command, chdir: rust_dir)
         return if status.success?
@@ -118,7 +146,7 @@ module Hecks
           raise BuildFailed, "`#{command.join(" ")}` succeeded in #{rust_dir} but left no executable at #{binary}"
         end
 
-        pinned = File.join(rust_dir, "target", "debug", "rust-#{domain_feature}")
+        pinned = pinned_path(rust_dir, domain_feature)
         FileUtils.cp(binary, pinned)
         File.chmod(0o755, pinned)
         pinned

data/lib/hecks/rust_build/wasm.rb

@@ -15,10 +15,15 @@ module Hecks
     # `wasmtime run rust/dist/<domain>.wasm < script.json`, and the domain's `ir.json` beside it,
     # which `rust/host` reads at runtime. `HECKS_RUST_DIR` names the workspace to build in and
     # `CARGO_TARGET_DIR` where build output goes, beside the workspace by default.
+    # `HECKS_WASM_PROFILE=dev` builds without `--release`: a much faster compile, for tests that
+    # only run the module, not for one that ships.
     module Wasm
       # The Cargo target the module is built for.
       TARGET = "wasm32-wasip1"
 
+      # The Cargo flags and the `target/<target>/` directory of each build profile.
+      PROFILES = { "release" => { flags: ["--release"], dir: "release" }, "dev" => { flags: [], dir: "debug" } }.freeze
+
       module_function
 
       # @param argv [Array<String>] the domain's directory
@@ -83,18 +88,26 @@ module Hecks
       # `rustup run`, not bare `cargo`: a `cargo` earlier on PATH may never have seen
       # `rustup target add` and fail with "can't find crate for `std`".
       def compile(scratch)
-        puts "== cargo build --release --target #{TARGET} =="
+        flags = profile.fetch(:flags)
+        puts "== cargo build #{flags.join(" ")} --target #{TARGET} =="
         target_dir = ENV.fetch("CARGO_TARGET_DIR", File.join(RustBuild.rust_dir, "target"))
-        RustBuild.command!("rustup", "run", "stable", "cargo", "build", "--release", "--target", TARGET,
+        RustBuild.command!("rustup", "run", "stable", "cargo", "build", *flags, "--target", TARGET,
                            chdir: scratch, env: { "CARGO_TARGET_DIR" => target_dir })
       end
 
+      # @return [Hash] the flags and directory of the profile `HECKS_WASM_PROFILE` names
+      # @raise [Failure] when the name is not `release` or `dev`
+      def profile
+        name = ENV.fetch("HECKS_WASM_PROFILE", "release")
+        PROFILES.fetch(name) { raise Failure, "HECKS_WASM_PROFILE=#{name} is not release or dev" }
+      end
+
       def publish(scratch, rust_dir, name)
         dist = File.join(rust_dir, "dist")
         FileUtils.mkdir_p(dist)
         target_dir = ENV.fetch("CARGO_TARGET_DIR", File.join(rust_dir, "target"))
         out = File.join(dist, "#{name}.wasm")
-        FileUtils.cp(File.join(target_dir, TARGET, "release", "rust.wasm"), out)
+        FileUtils.cp(File.join(target_dir, TARGET, profile.fetch(:dir), "rust.wasm"), out)
         puts "wrote #{out}"
         puts %(run it: wasmtime run #{out} < script.json)
         publish_sidecar(scratch, dist, name)

data/lib/hecks/site/bluebook/site.bluebook

@@ -107,6 +107,7 @@ Hecks.bluebook "Site" do
     attribute :distribution, DistributionId, optional: true
     attribute :expect_new, PathList, optional: true
     attribute :refs,      PolicyRefs, optional: true
+    attribute :url,       SiteUrl,   optional: true
     attribute :output,    Report,    optional: true
     attribute :refusal,   Report,    optional: true
     identified_by :run
@@ -155,6 +156,11 @@ Hecks.bluebook "Site" do
       attribute :value, String, pattern: '[^\t\n\r]'
     end
 
+    # A running site's address, `https://example.org`: what `check_site` sends its requests to.
+    value_object "SiteUrl" do
+      attribute :value, String, pattern: '^https?://[^ \t\n\r]+$'
+    end
+
     value_object "Report" do
       attribute :value, String
     end
@@ -224,6 +230,26 @@ Hecks.bluebook "Site" do
       emits "LiveCheckRequested"
     end
 
+    # `hecks site site_projection.check_site <project> url=<https://example.org>`. Asks a running
+    # site what its route table says it must answer, with anonymous requests that follow no
+    # redirect and change nothing: an admin route refuses, an indexable public page answers 200
+    # with a canonical link, an `off` row and an undeclared path answer 404, and a redirect row
+    # redirects to its target. Routes that name a parameter or a prefix are left out. It prints a
+    # line per check and exits 1 when any answer is wrong.
+    command "CheckSite" do
+      goal "Ask a running site what its route table says it must answer, and judge each answer"
+
+      attribute :domain, DomainPath
+      attribute :run,    RunKey
+      attribute :url,    SiteUrl
+
+      sets :domain
+      sets :run
+      sets :url
+
+      emits "SiteProbeRequested"
+    end
+
     command "Complete" do
       goal "Record that routes.ts was written, or found current, or the live edge matched, and what it said"
 
@@ -270,6 +296,11 @@ Hecks.bluebook "Site" do
     trigger SiteProjection::SiteToolchain::Compare, with: { run: :run }
   end
 
+  policy "ProbeWhenRequested" do
+    on      "SiteProjection.SiteProbeRequested"
+    trigger SiteProjection::SiteToolchain::Probe, with: { run: :run }
+  end
+
   policy "RecordTheProjection" do
     on      "SiteProjection.SiteAnswered"
     trigger SiteProjection::Complete, with: { output: :output }

data/lib/hecks/site/bluebook/site.ports.hecksagon

@@ -17,5 +17,11 @@ Hecks.hecksagon "Site" do
       answers "SiteAnswered"
       refuses "SiteRefused"
     end
+
+    asks "Probe", to: SiteProjection do
+      attribute :run, RunKey
+      answers "SiteAnswered"
+      refuses "SiteRefused"
+    end
   end
 end

data/lib/hecks/tools/deploy_recipe/generation.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../../tools"
+require_relative "targets"
+
+module Hecks
+  module Tools
+    module DeployRecipe
+      # Writing the recipe for each `deployed_to` block a world declares: a client may declare
+      # several deploy kinds (Vercel beside AwsBox), and each is generated, none locked out.
+      module Generation
+        # @param deployment [Deployment] what the generator resolved about the domain
+        # @param root [String] the checkout
+        # @return [String] `--out`, else `deploy/<name>` in the checkout
+        def output_dir(deployment, root)
+          out = deployment.options.out
+          out ? File.expand_path(out) : File.join(root, "deploy", deployment.infra_name)
+        end
+
+        # One declared target, written straight into `out_dir` as it always was.
+        #
+        # @param block [Hash, nil] the target's settings; nil takes the world's plain `deployed_to`
+        # @return [Integer] 0
+        def generate_one(deployment, root, out_dir, block = nil)
+          emit(block ? for_target(deployment, block) : deployment, root, out_dir)
+          0
+        end
+
+        # Several declared targets, each under its own `out_dir/<adapter>` so their `Makefile`s and
+        # scripts do not collide.
+        #
+        # @return [Integer] 0
+        def generate_each(deployment, root, out_dir, blocks)
+          blocks.each do |block|
+            emit(for_target(deployment, block), root, File.join(out_dir, block[:adapter].downcase))
+          end
+          0
+        end
+
+        # @param view [Deployment] the deployment as one target sees it
+        # @return [void] writes the files the target projects into `out_dir`
+        def emit(view, root, out_dir)
+          write(project(target_key(view.settings, view.world_file, view.domain), view, root), out_dir)
+        end
+
+        # @param block [Hash] one declared `deployed_to` block
+        # @return [Deployment] the deployment as that target sees it: its settings, name and world
+        def for_target(deployment, block)
+          settings = tenant_settings(block, deployment.options, File.basename(deployment.domain))
+          deployment.dup.tap do |view|
+            view.world = Targets::TargetWorld.new(deployment.world, block)
+            view.settings = settings
+            view.infra_name = settings[:stack_name] || File.basename(deployment.domain)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/tools/deploy_recipe/targets.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "delegate"
 require_relative "../../tools"
 
 module Hecks
@@ -11,7 +12,7 @@ module Hecks
         # The refusal for a world with no deploy target, where `__WORLD_FILE__` and `__DOMAIN__`
         # stand for the world file and the domain directory.
         NO_TARGET = <<~MSG
-          __WORLD_FILE__ declares no deployed_to("AwsLambda"), deployed_to("AwsFargate") or deployed_to("AwsBox") block. Add one, e.g.:
+          __WORLD_FILE__ declares no deployed_to("AwsLambda"), deployed_to("AwsFargate"), deployed_to("AwsBox"), deployed_to("AwsSharedDatabase") or deployed_to("Vercel") block. Add one, e.g.:
 
               deployed_to("AwsLambda") do
                 region "us-east-1"
@@ -35,22 +36,75 @@ module Hecks
                 containers [{ name: "web", port: 8080 }]
               end
 
+          or, for the RDS instance several sites share:
+
+              deployed_to("AwsSharedDatabase") do
+                region "us-east-1"
+                stack_name "hecks-platform-rds"
+              end
+
+          or:
+
+              deployed_to("Vercel") do
+                region "iad1"
+                env ["SESSION_SECRET"]
+              end
+
           then re-run hecks deploy project __DOMAIN__.
         MSG
 
+        # A world view whose `deployed_to` answers for one declared target, so a projector that
+        # reads `world.for_verb("deployed_to")` sees that target's block and no other.
+        class TargetWorld < SimpleDelegator
+          # @param world [Object] the world the blocks were declared in
+          # @param settings [Hash{Symbol => Object}] the one `deployed_to` block this view uses
+          def initialize(world, settings)
+            super(world)
+            @settings = settings
+          end
+
+          # @return [Hash{Symbol => Object}] this target's block for `deployed_to`, else the world's
+          def for_verb(verb) = verb.to_s == "deployed_to" ? @settings : super
+        end
+
+        # Every `deployed_to` block the world declares, in declaration order. The world records
+        # each one as `deployed_to:<adapter>`; the plain `deployed_to` entry is only the last.
+        #
+        # @param world [Object] the loaded world
+        # @return [Array<Hash{Symbol => Object}>] one settings hash per target, with its `:adapter`
+        def declared_targets(world)
+          world.settings.filter_map { |key, block| block if key.to_s.start_with?("deployed_to:") }
+        end
+
+        # @param blocks [Array<Hash>] the declared targets
+        # @param wanted [String, nil] the `--target` flag
+        # @return [Array<Hash>] the targets to generate: all, or the one named
+        # @raise [SystemExit] when the world declares no such target
+        def chosen_targets(blocks, wanted)
+          return blocks unless wanted
+
+          found = blocks.select { |block| block[:adapter].casecmp?(wanted) }
+          return found unless found.empty?
+
+          declared = blocks.map { |block| block[:adapter] }.join(", ")
+          abort "no deployed_to(#{wanted.inspect}) is declared; declared: #{declared}"
+        end
+
         # Each adapter maps to a registered `Projector` export (`needs_world: true`); this only
         # finds which one to call.
         #
         # @param deploy_settings [Hash] the world's `deployed_to` settings
         # @param world_file [String] the `.world` file, named in the refusal
         # @param domain [String] the domain directory, named in the refusal
-        # @return [Symbol] `:aws_lambda`, `:aws_fargate` or `:aws_box`
+        # @return [Symbol] the key of the registered projection, such as `:aws_box` or `:vercel`
         # @raise [SystemExit] with an example block when the world declares none of them
         def target_key(deploy_settings, world_file, domain)
           case deploy_settings[:adapter]
           when "AwsLambda" then :aws_lambda
           when "AwsFargate" then :aws_fargate
           when "AwsBox" then :aws_box
+          when "AwsSharedDatabase" then :aws_shared_database
+          when "Vercel" then :vercel
           else
             abort NO_TARGET.gsub("__WORLD_FILE__") { world_file }.gsub("__DOMAIN__") { domain }
           end

data/lib/hecks/tools/deploy_recipe/worlds.rb

@@ -21,7 +21,8 @@ module Hecks
 
           File.exist?(world_file) or
             abort "#{world_file} does not exist — a domain needs a .world file to declare " \
-                  "deployed_to(\"AwsLambda\"), deployed_to(\"AwsFargate\") or deployed_to(\"AwsBox\")"
+                  "deployed_to(\"AwsLambda\"), deployed_to(\"AwsFargate\"), deployed_to(\"AwsBox\"), " \
+                  "deployed_to(\"AwsSharedDatabase\") or deployed_to(\"Vercel\")"
           world_file
         end
 

data/lib/hecks/tools/deploy_recipe.rb

@@ -6,6 +6,7 @@ require "optparse"
 require_relative "../tools"
 require_relative "deploy_recipe/worlds"
 require_relative "deploy_recipe/targets"
+require_relative "deploy_recipe/generation"
 
 module Hecks
   module Tools
@@ -14,7 +15,7 @@ module Hecks
     # scripts and Makefile) under `deploy/<stack>/` of the checkout.
     #
     #   hecks deploy recipe.project <domain> [--tenant=<slug>] [--schema=<name>]
-    #       [--out=<dir>] [--environment=<name>]
+    #       [--out=<dir>] [--environment=<name>] [--target=<adapter>]
     #
     # `--environment` layers an overlay `.world` file over the base one; a missing overlay is an
     # error. `--out` writes the recipe elsewhere, for a domain in a client's repo. `--tenant` and
@@ -22,13 +23,13 @@ module Hecks
     # re-running with the same `--tenant` regenerates the same stack.
     module DeployRecipe
       USAGE = "usage: hecks deploy project <domain> [--tenant=<slug>] [--schema=<name>] " \
-              "[--out=<dir>] [--environment=<name>]"
+              "[--out=<dir>] [--environment=<name>] [--target=<adapter>]"
 
       # The directory `ports/` and `adapters/` live under, loaded into every domain's registry.
       LIB_HECKS = File.expand_path("..", __dir__)
 
       # What the flags asked for.
-      Options = Struct.new(:tenant, :out, :environment)
+      Options = Struct.new(:tenant, :out, :environment, :target)
 
       # What the generator resolved about a domain: its directory, the flags, the `.world` file and
       # its declaration, the `deployed_to` settings, the stack's name, the registry and the chapter.
@@ -36,6 +37,7 @@ module Hecks
 
       extend Worlds
       extend Targets
+      extend Generation
 
       module_function
 
@@ -53,17 +55,19 @@ module Hecks
         domain = argv.shift or abort USAGE
 
         deployment = resolve(domain, options)
-        out_dir = options.out ? File.expand_path(options.out) : File.join(root, "deploy", deployment.infra_name)
-        target = target_key(deployment.settings, deployment.world_file, domain)
-        write(project(target, deployment, root), out_dir)
-        0
+        blocks = chosen_targets(declared_targets(deployment.world), options.target)
+        out_dir = output_dir(deployment, root)
+        # No block at all falls through to the refusal that shows an example.
+        return generate_each(deployment, root, out_dir, blocks) if blocks.size > 1
+
+        generate_one(deployment, root, out_dir, blocks.first)
       end
 
       # @param argv [Array<String>] the arguments; the flags are removed from it
       # @return [Options] the flags, with `tenant` a hash of `tenant` and `schema`
       # @raise [SystemExit] when `--schema` has no `--tenant`
       def parse(argv)
-        options = Options.new({}, nil, nil)
+        options = Options.new({}, nil, nil, nil)
         option_parser(options).parse!(argv)
 
         if options.tenant[:schema] && !options.tenant[:tenant]
@@ -77,11 +81,17 @@ module Hecks
         OptionParser.new do |parser|
           parser.on("--tenant=SLUG") { |v| options.tenant[:tenant] = v }
           parser.on("--schema=NAME") { |v| options.tenant[:schema] = v }
-          parser.on("--out=DIR") { |v| options.out = v }
-          parser.on("--environment=NAME") { |v| options.environment = v }
+          where_flags(parser, options)
         end
       end
 
+      # @return [void] the flags that say where to write and which target to write
+      def where_flags(parser, options)
+        parser.on("--out=DIR") { |v| options.out = v }
+        parser.on("--environment=NAME") { |v| options.environment = v }
+        parser.on("--target=ADAPTER") { |v| options.target = v }
+      end
+
       # @param domain [String] the domain directory
       # @param options [Options] the flags
       # @return [Deployment] the world, settings, registry and chapter the recipe is projected from