strata-cli 0.1.20 → 0.1.22

data/lib/strata/cli/helpers/semantic_audit_checks.rb

@@ -13,6 +13,7 @@ module Strata
     #
     # Server-only checks (universe/path integrity, physical table existence
     # in the warehouse, licenses) are deliberately not replicated here.
+
     module SemanticAuditChecks
       # deployer/handlers/table.rb dispatches on the literal string
       # "dimension"; any other value silently becomes a measure and a
@@ -24,7 +25,7 @@ module Strata
       DISPLAY_TYPES = %w[default html url email phone_number image].freeze
       DATE_GRAINS = %w[raw millisecond second minute hour day month week quarter year].freeze
       NUMERIC_DATA_TYPES = %w[integer decimal bigint].freeze
-      # semantic/measure.rb + measure/excludable.rb + measure/includable.rb
+      # semantic/measure.rb + semantic/measure/excludable.rb + semantic/measure/includable.rb
       SNAPSHOT_TYPES = %w[beginning ending].freeze
       EXCLUSION_TYPES = %w[exclude exclude_all_except exclude_all].freeze
       EXCLUSION_ENTITY_TYPES = %w[dimension table universe].freeze
@@ -34,8 +35,8 @@ module Strata
       DYNAMIC_DATE = /(\d{1,3})([hdwmqy])/i
       # semantic/join_def.rb enums — note: no many_to_many.
       JOIN_TYPES = %w[inner left right].freeze
-      # semantic/expression.rb:17 — the server accepts any word(...) call.
-      MEASURE_SQL_FORMAT = /\A.*\w+\(.*\).*\z/i
+      # semantic/expression.rb:17 — any word(...) call. /m so a block scalar or a measure spanning lines still matches.
+      MEASURE_SQL_FORMAT = /\A.*\w+\(.*\).*\z/im
 
       private
 
@@ -65,9 +66,11 @@ module Strata
           next if name.empty?
 
           if seen_names[name]
+            # handlers/datasource.rb:18-20 merges them onto one row, so tables
+            # silently repoint at the other warehouse.
             failures << {
               file: "datasources.yml",
-              message: "Datasource '#{key}' duplicates the name '#{config["name"]}' used by '#{seen_names[name]}'"
+              message: "Datasource '#{key}' duplicates the name '#{config["name"]}' used by '#{seen_names[name]}' (on deploy they merge into one datasource)"
             }
           else
             seen_names[name] = key
@@ -82,6 +85,7 @@ module Strata
       def validate_field_semantics(field, file, failures, meta)
         name = field["name"]
 
+        # handlers/table.rb:113 turns anything but "dimension" into a Measure.
         unless FIELD_TYPES.include?(field["type"].to_s.downcase.strip)
           failures << {
             file: file,
@@ -90,10 +94,29 @@ module Strata
         end
 
         validate_field_enums(name, field, file, failures)
-        validate_measure_rules(name, field, file, failures)
+        if field["type"].to_s.downcase.strip == "dimension"
+          validate_no_measure_keys(name, field, file, failures)
+        else
+          validate_measure_rules(name, field, file, failures)
+        end
         validate_expression_semantics(name, field, file, failures, meta)
       end
 
+      # Written to a dimension by handlers/table.rb:119 but untyped, so
+      # `snapshot: ending` stores 0 and reads back as `beginning`.
+      MEASURE_ONLY_KEYS = %w[snapshot exclusion_type exclusions inclusions].freeze
+
+      def validate_no_measure_keys(name, field, file, failures)
+        present = MEASURE_ONLY_KEYS.select { field.key?(it) }
+        return if present.empty?
+
+        failures << {
+          file: file,
+          message: "Field '#{name}' is a dimension, so #{present.sort.join(", ")} #{(present.size == 1) ? "does" : "do"} not apply " \
+            "(#{(present.size == 1) ? "it is" : "they are"} measure-only; the server stores the value untyped and never reads it)"
+        }
+      end
+
       def validate_field_enums(name, field, file, failures)
         data_type = field["data_type"].to_s.strip
         if data_type.empty?
@@ -105,7 +128,8 @@ module Strata
           }
         end
 
-        if field.key?("display_type") && !DISPLAY_TYPES.include?(field["display_type"].to_s)
+        # field.rb:16 is a nullable enum: an empty key is an absent one.
+        if !field["display_type"].to_s.strip.empty? && !DISPLAY_TYPES.include?(field["display_type"].to_s)
           failures << {
             file: file,
             message: "Field '#{name}' has invalid display_type '#{field["display_type"]}' (expected one of: #{DISPLAY_TYPES.join(", ")})"
@@ -119,7 +143,8 @@ module Strata
       end
 
       def validate_measure_rules(name, field, file, failures)
-        if field.key?("snapshot") && !SNAPSHOT_TYPES.include?(field["snapshot"].to_s)
+        # measure.rb:6 is `enum :snapshot, [...], validate: {allow_nil: true}`.
+        if !field["snapshot"].to_s.strip.empty? && !SNAPSHOT_TYPES.include?(field["snapshot"].to_s)
           failures << {
             file: file,
             message: "Field '#{name}' has invalid snapshot '#{field["snapshot"]}' (expected beginning or ending)"
@@ -139,6 +164,16 @@ module Strata
           failures << {file: file, message: "Field '#{name}' exclusions should be empty when exclusion_type is exclude_all"}
         end
 
+        # excludable.rb:9,12 gates the rules on exclusion_type, so without it they
+        # are stored and never applied.
+        if exclusions.any? && exclusion_type.to_s.strip.empty?
+          failures << {
+            file: file,
+            message: "Field '#{name}' has exclusions but no 'exclusion_type', so the server stores the rules and never applies them"
+          }
+          exclusions = []
+        end
+
         exclusions.each_with_index do |rule, idx|
           unless rule.is_a?(Hash)
             failures << {file: file, message: "Field '#{name}' exclusion at index #{idx} must be a mapping"}
@@ -181,14 +216,14 @@ module Strata
         end
       end
 
-      # ---- expressions (semantic/expression.rb, expression/references.rb) ----
+      # ---- expressions (semantic/expression.rb, semantic/expression/references.rb) ----
 
       def validate_expression_semantics(name, field, file, failures, meta)
         sql = expression_sql(field["expression"])
         return unless sql
 
         begin
-          parsed = Sql::ExpressionParser.new(sql, reserved: meta[:reserved], aggregates: meta[:aggregates])
+          parsed = Sql::ExpressionParser.new(sql, reserved: meta[:reserved], aggregates: meta[:aggregates], quote: meta[:quote])
         rescue => e
           failures << {file: file, message: "Field '#{name}': expression could not be parsed: #{e.message}"}
           return
@@ -236,7 +271,7 @@ module Strata
           if types.nil?
             failures << {file: file, message: "Field '#{name}': [#{ref}] field was not found in the project"}
           elsif types.size > 1
-            # references.rb:97
+            # references.rb:98
             failures << {
               file: file,
               message: "Field '#{name}': [#{ref}] matched multiple fields. Use @m or @d to specify the field further."
@@ -246,7 +281,7 @@ module Strata
           end
         end
 
-        # references.rb:127-131
+        # references.rb:126-132
         if dimension && measure_refs.any?
           failures << {
             file: file,
@@ -286,7 +321,7 @@ module Strata
           return
         end
 
-        # deployer/handlers/table.rb:204 + table/snappable.rb:40-43
+        # deployer/handlers/table.rb:204 + table/snappable.rb:38-43
         unless (project_semantic_index[:fields][snap_name] || []).include?("dimension")
           failures << {file: file, message: "Snapshot dimension '#{content["snapshot"]}' was not found in the project"}
           return
@@ -294,6 +329,8 @@ module Strata
 
         data_type = project_semantic_index[:dimension_data_types][snap_name].to_s
         unless %w[date date_time].include?(data_type)
+          # snappable.rb:38-43, which skip_reference_validation keeps off the
+          # deploy path -- snapshot_visitor then returns a wrong number silently.
           failures << {
             file: file,
             message: "Snapshot date '#{content["snapshot"]}' must be a date or date_time dimension (got '#{data_type}')"
@@ -388,11 +425,13 @@ module Strata
 
           sql = definition["sql"].to_s.downcase
           # join_def.rb:70-77
-          if !sql.empty? && !(sql.match?(/left\./) && sql.match?(/right\./))
+          if !sql.empty? && !(sql.include?("left.") && sql.include?("right."))
             failures << {file: file, message: "Relationship '#{key}' join sql should be of the format left.column = right.column"}
           end
 
-          if definition.key?("join") && !JOIN_TYPES.include?(definition["join"].to_s)
+          # relationships.rb:121 downcases and defaults to "inner" first.
+          join = definition["join"].to_s.downcase.strip
+          if !join.empty? && !JOIN_TYPES.include?(join)
             failures << {
               file: file,
               message: "Relationship '#{key}' has invalid join '#{definition["join"]}' (expected one of: #{JOIN_TYPES.join(", ")})"
@@ -404,19 +443,19 @@ module Strata
       end
 
       def validate_relationship_tables(key, definition, ds_key, file, failures)
-        tables = project_semantic_index[:tables]
+        table_datasources = project_semantic_index[:table_datasources]
         left = definition["left"].to_s.downcase.strip
         right = definition["right"].to_s.downcase.strip
 
         [["left", left], ["right", right]].each do |side, table_name|
           next if table_name.empty?
 
-          table = tables[table_name]
-          if table.nil?
+          declared_in = table_datasources[table_name]
+          if declared_in.nil?
             # deployer/handlers/relationships.rb:106-107
             failures << {file: file, message: "Relationship '#{key}': #{side} table '#{definition[side]}' was not found in the project"}
-          elsif ds_key && (table_ds = resolve_datasource_value(table["datasource"])) && table_ds != ds_key
-            # join_def.rb:65-67
+          elsif ds_key && !declared_in.include?(ds_key)
+            # join_def.rb:65-67 — the name is taken in some other datasource only.
             failures << {
               file: file,
               message: "Relationship '#{key}': #{side} table '#{definition[side]}' is not in datasource '#{ds_key}' (tables can only join within one datasource)"
@@ -427,14 +466,18 @@ module Strata
         return if left.empty? || right.empty?
 
         # join_def.rb:79-83 — joins are bi-directional, so either order collides.
-        pair = [left, right].sort
+        # Scoped by datasource: the pair identifies table records.
+        pair = [ds_key, *[left, right].sort]
         if (existing = seen_join_pairs[pair])
+          # relationships.rb:113-115 raises within a file; across files
+          # first_or_initialize lets glob order decide. Non-deterministic either way.
           failures << {
             file: file,
-            message: "Relationship '#{key}': a join between '#{definition["left"]}' and '#{definition["right"]}' already exists (#{existing})"
+            message: "Relationship '#{key}': a join between '#{definition["left"]}' and '#{definition["right"]}' " \
+              "already exists (#{existing[:file]}: #{existing[:key]})"
           }
         else
-          seen_join_pairs[pair] = "#{file}: #{key}"
+          seen_join_pairs[pair] = {file: file, key: key}
         end
       end
 
@@ -442,19 +485,26 @@ module Strata
         @seen_join_pairs ||= {}
       end
 
+      # Reported without failing the audit.
+      def semantic_warnings
+        @semantic_warnings ||= []
+      end
+
       # ---- shared infrastructure ----
 
       # Name index of every table and field declared across the project's
       # tbl.*.yml files, keyed by lowercased name (the server resolves
       # references by lower(name), and the expression parser downcases its
       # input, so lowercase keys line up on both sides).
+      # Fields stay keyed by name alone (uniqueness scope: [:type, :branch_id]);
+      # tables are per-datasource, so that index maps a name to its datasources.
       def project_semantic_index
         @project_semantic_index ||= begin
           fields = {}
           dimension_data_types = {}
-          tables = {}
+          table_datasources = {}
 
-          Dir.glob("models/**/*.yml").each do |file|
+          Dir.glob("models/**/*.{yml,yaml}").each do |file|
             next unless File.basename(file).start_with?("tbl.")
 
             content = begin
@@ -466,7 +516,9 @@ module Strata
 
             table_name = content["name"].to_s.downcase.strip
             unless table_name.empty?
-              tables[table_name] = {"datasource" => content["datasource"], "file" => file}
+              # Unique per datasource (semantic/table.rb:32), so one name can
+              # belong to several.
+              (table_datasources[table_name] ||= []) << resolve_datasource_value(content["datasource"])
             end
 
             Array(content["fields"]).each do |f|
@@ -481,7 +533,7 @@ module Strata
             end
           end
 
-          {fields: fields, tables: tables, dimension_data_types: dimension_data_types}
+          {fields: fields, table_datasources: table_datasources, dimension_data_types: dimension_data_types}
         end
       end
 
@@ -492,14 +544,20 @@ module Strata
       def adapter_meta(ds_value)
         @adapter_meta ||= {}
         key = resolve_datasource_value(ds_value)
-        config = (key && (datasources[key] || datasources[key.to_s.downcase.strip])) || {}
+        config = (key && datasources[key]) || {}
         sym = config["adapter"].to_s.downcase.strip.to_sym
 
         @adapter_meta[sym] ||= if DWH.adapter?(sym)
           klass = DWH.get_adapter(sym)
-          {reserved: klass.reserved_keywords, aggregates: klass.aggregate_functions}
+          {
+            reserved: klass.reserved_keywords,
+            aggregates: klass.aggregate_functions,
+            # references.rb:5-8 passes the adapter's own identifier quote, so a
+            # backtick warehouse reads `order` as a column.
+            quote: klass.adapter_settings[:quote]
+          }
         else
-          {reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions}
+          {reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions, quote: Sql::ExpressionParser::ANSI_QUOTE}
         end
       end
     end

data/lib/strata/cli/main.rb

@@ -30,21 +30,19 @@ module Strata
         say VERSION
       end
 
-      desc "init [PROJECT_NAME]", "Initializes a new Strata project. PROJECT_NAME is optional when using --source."
+      desc "init PROJECT_NAME", "Initializes a new Strata project."
       long_desc_from_file "init"
       option :datasource, aliases: ["d"], type: :string, desc: "One of the supported data warehouse adapters.",
         repeatable: true
-      option :source, aliases: ["s"], type: :string, desc: "URL of existing project"
-      option :api_key, aliases: ["a"], type: :string, desc: "Api Key. Required if initializing existing project."
+      option :server, aliases: ["s"], type: :string, desc: "Strata server URL. Defaults to #{Configuration::DEFAULT_SERVER}."
+      option :api_key, aliases: ["a"], type: :string, desc: "Api Key. Optional — the first deploy signs you in via browser."
       option :verbose, aliases: ["v"], type: :boolean, default: false,
         desc: "Show detailed init output (file-by-file actions)."
 
       def init(project_name = nil)
-        unless project_name || options[:source]
-          raise Strata::CommandError, "PROJECT_NAME is required when not using --source option."
-        end
+        raise Strata::CommandError, "PROJECT_NAME is required." unless project_name
 
-        print_status(:created, (project_name || "project from source").to_s, type: :info)
+        print_status(:created, project_name.to_s, type: :info)
         invoke Generators::Project, [project_name], options
       end
 

data/lib/strata/cli/sub_commands/audit.rb

@@ -24,7 +24,7 @@ module Strata
         include SemanticAuditChecks
         include AgentMode
 
-        REQUIRED_KEYS_FOR_TABLE_MODEL = %w[name physical_name fields datasource].freeze
+        REQUIRED_KEYS_FOR_TABLE_MODEL = %w[name physical_name datasource].freeze
         REQUIRED_KEYS_FOR_RELATIONSHIP_MODEL = ["datasource"].freeze
         REQUIRED_KEYS_FOR_RELATIONSHIP_DEFINITION = %w[left right sql cardinality].freeze
         RELATIONSHIP_CARDINALITIES = %w[one_to_one one_to_many many_to_one].freeze
@@ -35,7 +35,15 @@ module Strata
           exclusions inclusions extended_blend_group synonyms expression tags
         ].freeze
         ALLOWED_EXPRESSION_KEYS = %w[sql array lookup primary_key].freeze
+        # What the deployer reads from a tbl file (handlers/table.rb:4, :62, :71,
+        # :152, :202), plus the CLI's own imports.
+        ALLOWED_TABLE_KEYS = %w[
+          name description physical_name cost metadata tags
+          datasource fields snapshot partition partitions imports
+        ].freeze
         STRAY_SCRIPT_EXTENSIONS = %w[.rb .py .sh .ipynb].freeze
+        # deploy_job.rb:121,162 globs models as {yml,yaml}, so both are models.
+        MODEL_EXTENSIONS = %w[.yml .yaml].freeze
         EXPRESSION_BOOLEAN_KEYS = %w[array lookup primary_key].freeze
 
         # Set default command so `strata audit` still works as `strata audit all`
@@ -46,8 +54,10 @@ module Strata
           results = {}
           results[:yaml] = run_check("Checking YAML syntax") { audit_yaml_syntax }
           results[:models] = run_check("Checking model definitions") { audit_models }
-          results[:connections] = run_check("Checking data source connections") { audit_connections }
+          results[:connections] = run_check("Checking data source connections") { audit_connections(semantic_warnings) }
 
+          warn_semantic_warnings
+          warn_unverifiable_datasources
           warn_stray_files
           report_results(results)
         end
@@ -61,12 +71,15 @@ module Strata
         desc "models", "Check model definitions and schema structure"
         def models
           results = {models: run_check("Checking model definitions") { audit_models }}
+          warn_semantic_warnings
           report_results(results)
         end
 
         desc "connections", "Check data source connections"
         def connections
           results = {connections: run_check("Checking data source connections") { audit_connections }}
+          warn_semantic_warnings
+          warn_unverifiable_datasources
           report_results(results)
         end
 
@@ -84,7 +97,7 @@ module Strata
         # A Strata project holds YAML, not scripts. Agents sometimes leave scratch
         # validators behind; warn, don't fail — a helper script is the user's call.
         def warn_stray_files
-          strays = Dir.glob("models/**/*").select { File.file?(it) && File.extname(it) != ".yml" }
+          strays = Dir.glob("models/**/*").select { File.file?(it) && !MODEL_EXTENSIONS.include?(File.extname(it)) }
           strays += Dir.glob("*").select { File.file?(it) && STRAY_SCRIPT_EXTENSIONS.include?(File.extname(it)) }
           return if strays.empty?
 
@@ -92,6 +105,25 @@ module Strata
           strays.sort.each { print_warning("    #{it}") }
         end
 
+        # Problems the server tolerates: shown, but never failed.
+        def warn_semantic_warnings
+          return if semantic_warnings.empty?
+
+          print_warning("\n  Accepted by the server, but worth a look:")
+          semantic_warnings.each { print_warning("    #{it[:file]}: #{it[:message]}") }
+        end
+
+        # Pointing a datasource at a path the server owns is a normal setup — the sample
+        # project's /data/tpcds.duckdb ships inside the Strata image — so say which
+        # connections went unchecked instead of failing a correct project.
+        def warn_unverifiable_datasources
+          skipped = datasources.select { |_key, config| local_file_missing?(config) }
+          return if skipped.empty?
+
+          print_warning("\n  Connection not checked — file not on this machine (the server opens it at deploy):")
+          skipped.each { |key, config| print_warning("    #{key}: #{config["file"]}") }
+        end
+
         def run_check(message)
           failures = []
           with_spinner(message) do
@@ -108,7 +140,7 @@ module Strata
         end
 
         def audit_yaml_syntax
-          files = Dir.glob("models/**/*.yml") + ["datasources.yml"].select { |f| File.exist?(f) }
+          files = Dir.glob("models/**/*.{yml,yaml}") + ["datasources.yml"].select { |f| File.exist?(f) }
 
           failures = []
           files.each do |file|
@@ -123,7 +155,7 @@ module Strata
 
         def audit_models
           failures = audit_datasource_definitions
-          Dir.glob("models/**/*.yml").each do |file|
+          Dir.glob("models/**/*.{yml,yaml}").each do |file|
             audit_imports(file, failures)
             audit_model_file(file, failures)
           end
@@ -160,19 +192,34 @@ module Strata
           end
         end
 
+        # handlers/table.rb:54 drops it, so an unquoted `yes:` does nothing.
         def validate_structure(content, file, failures)
           content.each_key do |k|
-            failures << {file: file, message: "Top level key #{k} is not a string"} unless k.is_a?(String)
+            next if k.is_a?(String)
+
+            failures << {file: file, message: "Top level key #{k} is not a string"}
           end
         end
 
         def validate_table_model(content, file, failures)
           validate_required_keys(content, file, REQUIRED_KEYS_FOR_TABLE_MODEL, failures)
+          validate_table_keys(content, file, failures)
           validate_datasource_reference(content, file, failures)
           validate_table_fields(content["fields"], file, failures, adapter_meta(content["datasource"]))
           validate_table_semantics(content, file, failures)
         end
 
+        # Same slice: `snapshot_date:` deploys a table with no snapshot date.
+        def validate_table_keys(content, file, failures)
+          unknown_keys = content.keys.select { it.is_a?(String) }.map(&:to_s) - ALLOWED_TABLE_KEYS
+          return if unknown_keys.empty?
+
+          failures << {
+            file: file,
+            message: "Table has unknown top-level #{(unknown_keys.size == 1) ? "key" : "keys"}: #{unknown_keys.sort.join(", ")}"
+          }
+        end
+
         def validate_relationship_model(content, file, failures)
           validate_required_keys(content, file, REQUIRED_KEYS_FOR_RELATIONSHIP_MODEL, failures)
           validate_datasource_reference(content, file, failures)
@@ -198,13 +245,14 @@ module Strata
         end
 
         def validate_table_fields(fields, file, failures, adapter_meta)
-          unless fields.is_a?(Array)
-            failures << {file: file, message: "'fields' must be an array"}
+          # handlers/table.rb:62 returns early, so a fieldless table deploys fine.
+          if fields.nil? || (fields.is_a?(Array) && fields.empty?)
+            semantic_warnings << {file: file, message: "Table has no fields, so it contributes nothing to the model yet"}
             return
           end
 
-          if fields.empty?
-            failures << {file: file, message: "'fields' must not be empty"}
+          unless fields.is_a?(Array)
+            failures << {file: file, message: "'fields' must be an array"}
             return
           end
 
@@ -221,6 +269,8 @@ module Strata
         def validate_field_definition(field, file, idx, failures, adapter_meta)
           field_name = field["name"] || "index #{idx}"
 
+          # handlers/table.rb:119 drops the rest, so on an existing field
+          # `datatype:` for `data_type:` silently leaves the old value.
           unknown_keys = field.keys.map(&:to_s) - ALLOWED_FIELD_KEYS
           if unknown_keys.any?
             failures << {
@@ -234,6 +284,7 @@ module Strata
 
           return unless field.key?("format")
 
+          # Normalized to nil and skipped (formattable.rb:10), so it never appears.
           validate_field_format(field_name, field["format"], file, failures)
         end
 
@@ -273,31 +324,40 @@ module Strata
             failures << {file: file, message: "Field '#{field_name}' expression must include non-empty 'sql'"}
           end
 
+          # ActiveModel::Type::Boolean casts everything outside FALSE_VALUES to
+          # true, so a quoted "no" stores the opposite. Bare `no` is fine.
           EXPRESSION_BOOLEAN_KEYS.each do |key|
             next unless expression.key?(key) || expression.key?(key.to_sym)
 
-            value = expression[key] || expression[key.to_sym]
+            value = expression.key?(key) ? expression[key] : expression[key.to_sym]
             next if value == true || value == false
 
-            failures << {
-              file: file,
-              message: "Field '#{field_name}' expression.#{key} must be true or false"
-            }
+            message = "Field '#{field_name}' expression.#{key} is #{value.inspect}, not true or false"
+            if INVERTS_TO_TRUE.include?(value)
+              message += " — the server stores it as true; write it unquoted"
+            end
+
+            failures << {file: file, message: message}
           end
         end
 
-        def validate_field_format(field_name, format_value, file, failures)
+        # Reads as false, casts to true -- absent from FALSE_VALUES.
+        INVERTS_TO_TRUE = ["no", "No", "NO", "n", "N", "nil", "null", "none"].freeze
+
+        def validate_field_format(field_name, format_value, file, problems)
           case format_value
+          when nil
+            problems << {file: file, message: "Field '#{field_name}' format must not be empty"}
           when String
             shortcut = format_value.strip
             if shortcut.empty?
-              failures << {file: file, message: "Field '#{field_name}' format must not be empty"}
+              problems << {file: file, message: "Field '#{field_name}' format must not be empty"}
               return
             end
 
             type = shortcut.split(":", 2).first
             unless VALID_FORMAT_TYPES.include?(type)
-              failures << {
+              problems << {
                 file: file,
                 message: "Field '#{field_name}' format shortcut has invalid type '#{type}' (expected one of: #{VALID_FORMAT_TYPES.join(", ")})"
               }
@@ -305,15 +365,15 @@ module Strata
           when Hash
             type = format_value["type"] || format_value[:type]
             if type.nil? || type.to_s.strip.empty?
-              failures << {file: file, message: "Field '#{field_name}' format hash must include type"}
+              problems << {file: file, message: "Field '#{field_name}' format hash must include type"}
             elsif !VALID_FORMAT_TYPES.include?(type.to_s)
-              failures << {
+              problems << {
                 file: file,
                 message: "Field '#{field_name}' format hash has invalid type '#{type}' (expected one of: #{VALID_FORMAT_TYPES.join(", ")})"
               }
             end
           else
-            failures << {
+            problems << {
               file: file,
               message: "Field '#{field_name}' format must be a string shortcut or a hash with type"
             }
@@ -340,16 +400,19 @@ module Strata
           validate_cardinality(name, definition["cardinality"], file, failures) if definition.key?("cardinality")
         end
 
+        # relationships.rb:122 normalizes before the enum sees it:
+        # `join_def["cardinality"]&.downcase&.strip`.
         def validate_cardinality(name, cardinality, file, failures)
-          return if RELATIONSHIP_CARDINALITIES.include?(cardinality)
+          return if RELATIONSHIP_CARDINALITIES.include?(cardinality.to_s.downcase.strip)
 
           failures << {file: file, message: "Relationship '#{name}' has invalid cardinality '#{cardinality}'"}
         end
 
-        def audit_connections
-          return [] if CLI.config.get("git").to_s.include?("tpc-ds-retail-sample")
-
+        # +unreachable+ takes the results: `connections` passes failures, `all`
+        # passes warnings -- the server never requires us to reach the warehouse.
+        def audit_connections(unreachable = nil)
           failures = []
+          unreachable ||= failures
 
           unless File.exist?("datasources.yml")
             failures << {file: "datasources.yml", message: "File not found"}
@@ -362,11 +425,15 @@ module Strata
             return failures
           end
 
-          datasources.each_key do |ds_key|
+          datasources.each do |ds_key, config|
+            # Skip before create_adapter: it would install the adapter's driver gem to
+            # open a file that isn't here. warn_unverifiable_datasources names these.
+            next if local_file_missing?(config)
+
             adapter = create_adapter(ds_key)
             adapter.test_connection(raise_exception: true)
           rescue => e
-            failures << {
+            unreachable << {
               file: "datasources.yml",
               message: "Connection failed for '#{ds_key}': #{e.message}"
             }

data/lib/strata/cli/sub_commands/datasource.rb

@@ -189,6 +189,12 @@ module Strata
           end
         rescue => e
           say "\t!! Failed to connect: \n\t#{e.message}", :red
+          # datasources[] rather than ds_config: an unknown key is one of the ways we
+          # get here, and ds_config raises on it.
+          if local_file_missing?(datasources[ds_key])
+            say "\tThat path is not on this machine. If it lives inside the Strata container " \
+              "(like the sample's /data/tpcds.duckdb), the server opens it at deploy and this is expected.", :yellow
+          end
         end
 
         desc "tables DS_KEY", "List tables from DS_KEY datasource"

data/lib/strata/cli/sub_commands/deploy.rb

@@ -149,36 +149,7 @@ module Strata
         end
 
         def ensure_server(config)
-          return if config["server"] && !config["server"].to_s.strip.empty?
-
-          config["server"] = collect_server_interactively
-        end
-
-        def collect_server_interactively
-          say "\nServer URL not found (not in project.yml)", :yellow
-          say "You can add it to project.yml or enter it now here\n", :cyan
-
-          server = prompt.ask("Enter Strata server URL:") do |q|
-            q.required true
-            q.validate(/\S+/, "Server URL cannot be empty")
-          end
-
-          server = server.strip.delete_suffix("/") # normalize: remove trailing slash
-
-          with_spinner("Saving server URL to project.yml") do
-            save_server_to_project_yml(server)
-          end
-
-          server
-        end
-
-        def save_server_to_project_yml(server)
-          Helpers::ProjectHelper.persist_server_to_project_yml(server, project_yml_path: File.join(project_path, Configuration::PROJECT_CONFIG_FILE))
-          CLI.config.reload!
-          return unless Utils::Git.git_repo?
-
-          Utils::Git.commit_file(Configuration::PROJECT_CONFIG_FILE, "[Strata-CLI] Add server URL to project.yml",
-            project_path)
+          config["server"] = Configuration.resolve_server(config["server"])
         end
 
         def ensure_git_url_populated