strata-cli 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8114ee5b03683396612b2831650670281cdcf3da321c40abc259e2e1a31847c9
-  data.tar.gz: e84f43d3831b3cfb28da805c728b9005801aca677c0deeb620639ccaf632d213
+  metadata.gz: 55ce87ef5e374c4b0a1c60a5e23081596108a353bc543272a7aa2b749fd56930
+  data.tar.gz: 27bc1dab19e8dbc6efb1256b25c36389a182157dad90bd9fdfd14f9c73f648af
 SHA512:
-  metadata.gz: e6c15b69e6170dd5196f94c31b91cb0d5c229c2703402d588c72b6de6899a07e73f62af5ebd2ef7fb127df2e8832eca594644c947ec917e40bcc3daec91822a6
-  data.tar.gz: 81f8cec6b27936af833f2bbfae9eb1b878d14a3fd0e828c7acab5399235cb3a64e8c19b10bb6b5345ad8331e7b0cfbbf4250ff48e23362648386abdd0bcfb32c
+  metadata.gz: 9e9824b911b205b5876c1c104cfa2c187c7d768197b87ffda5bf3d891bfd2abc9140309b422c173fe8d964a9fa4939aa331bdc6e8412e25b0e6a37d172e4453e
+  data.tar.gz: 0bc343e01fac99afacc7bb5e3c188d530c7b7ceafa359c0c269d38c32e536b837bca2038b95ad2962672c5ebcc961eb7a972f72fee91abc5a3707c22ebf64a49

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [0.1.22] - 2026-11-05
+
+### Fixed
+
+The local semantic audit added in 0.1.16 mirrors the server's deploy-time
+validations. Several of its checks rejected models the server accepts, which blocked
+`strata audit` -- and `strata deploy`, which runs it first.
+
+- **A table name reused in a second datasource**: the audit resolved a relationship's tables by name across the whole project, so two datasources declaring the same table collided and whichever file was read last won. A valid join in the other datasource failed with "is not in datasource ... (tables can only join within one datasource)", and the same join defined in both datasources failed as a duplicate. Table names are unique per datasource on the server, so both are now scoped to the relationship's own datasource. This is what hot-tier routing looks like, where one table is defined in a hot and a cold datasource.
+- **Datasource references that differ only in case**: `datasource: TPCDS` in a relationship file and `tpcds` in a table file resolved to different strings and compared as different datasources. An upper-case key in `datasources.yml` was also rejected outright as "not found", though the server resolves it. Both now match case-insensitively, as the server does.
+- **Measures written across lines**: the aggregate-function check was missing the server's `/m` flag, so any measure written as a YAML block scalar (`sql: |`) or spanning lines was reported as having no aggregation function.
+- **Quoted identifiers on backtick warehouses**: expressions were always parsed with ANSI double quotes, so on MySQL, BigQuery, ClickHouse and Databricks a backtick-quoted column read as no column at all and dimensions were rejected for not referencing one. The parser now takes the adapter's own identifier quote.
+- **`join` and `cardinality` casing**: `join: Inner` and `cardinality: Many_To_One` were rejected. The server downcases and strips both before validating, and defaults a missing `join` to `inner`.
+- **Explicitly empty keys**: `snapshot:`, `display_type:` and `join:` left blank were rejected; the server treats nil as absent.
+- **Tables with no fields**: `fields` was required and `fields: []` rejected, though the server accepts a table that declares none. It now warns instead.
+- **`.yaml` model files**: only `.yml` was ever read, so a `tbl.*.yaml` was reported as a stray file to delete, never validated, invisible to relationship checks, and left out of the deploy archive -- even though the server deploys `tbl.*.{yml,yaml}`.
+
+### Added
+
+The deployer silently swallows a number of mistakes: the deploy goes green and the
+model differs from the YAML. Those are the ones worth catching locally, so these are
+errors even though the server accepts them.
+
+- **Measure-only keys on a dimension**: `snapshot`, `exclusion_type`, `exclusions` and `inclusions` apply to measures only, but all four are columns on the shared `fields` table and the deployer writes them to a dimension untyped -- `snapshot: ending` stores `0`, which reads back as `beginning`, and shows up as `snapshot: 0` in field JSON. Reported once, naming the keys, instead of as several misleading enum errors.
+- **`exclusions` without `exclusion_type`**: the rules are stored, never validated and never applied, so the measure aggregates at the grain the rules existed to prevent; under row-level security the query then fails with an internal "Exclusion dim ids are not cached" error.
+- **Unknown table-level keys**: the deployer slices a `tbl` file down to the keys it reads, so anything else is dropped. In particular `snapshot_date:` -- which this project's own table template suggested until now -- deployed a table with no snapshot date at all.
+- **`lookup: "no"` and friends**: these land on boolean columns, and `ActiveModel::Type::Boolean` casts everything outside its `FALSE_VALUES` to **true**, so a quoted `"no"`, `"No"` or a bare `n` silently stores the opposite of what was written. Bare `no` is fine, so this is a one-character quoting difference that inverts join handling and is invisible in a diff. The error now says so.
+- **Table template**: `table.table_name.yml` suggested `snapshot_date:`, but the deployer reads `snapshot:`. Corrected in `AGENTS.md` in 0.1.18 and missed here.
+
+### Changed
+
+- **`strata audit connections` still fails on an unreachable warehouse; `strata audit all` now warns.** The server only checks that a datasource's config can build an adapter and never requires the warehouse to be reachable from this machine, so a warehouse behind a VPN or an IP allow-list no longer blocks a deploy that would have worked. Running `connections` is an explicit request to test them, so there it is still an error.
+
 ## [0.1.21] - 2026-11-04
 
 ### Added

data/lib/strata/cli/generators/templates/table.table_name.yml

@@ -26,7 +26,7 @@ cost: 10
 # Optional: If this is a snapshot table like an inventory table, you can 
 # set the snapshot date dimension here. This will allow the creation of 
 # snapshot measures on this table.
-# snapshot_date: <snapshot dimension name>
+# snapshot: <snapshot dimension name>
 
 # Optional: Tag table for additional metadata.
 # tags:

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

@@ -153,8 +153,9 @@ module Strata
 
         normalized = value.to_s.downcase.strip
 
-        # Match by key first
-        return value if datasources.key?(normalized)
+        datasources.each_key do |key|
+          return key if key.to_s.downcase.strip == normalized
+        end
 
         # Match by name (case-insensitive)
         datasources.each do |key, config|

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/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,9 @@ 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)
@@ -62,12 +71,14 @@ 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
@@ -86,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?
 
@@ -94,6 +105,14 @@ 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.
@@ -121,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|
@@ -136,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
@@ -173,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)
@@ -211,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
 
@@ -234,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 << {
@@ -247,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
 
@@ -286,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(", ")})"
               }
@@ -318,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"
             }
@@ -353,14 +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
+        # +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"}
@@ -381,7 +433,7 @@ module Strata
             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/utils/archive.rb

@@ -34,7 +34,9 @@ module Strata
         end
 
         private_class_method def collect_yml_files(project_path)
-          Dir.glob(File.join(project_path, "**", "*.yml")).select do |file_path|
+          # The server globs models as {yml,yaml} (deploy_job.rb:121,162), so a
+          # .yaml model has to ship too -- it used to be left out of the archive.
+          Dir.glob(File.join(project_path, "**", "*.{yml,yaml}")).select do |file_path|
             File.file?(file_path)
           end
         end

data/lib/strata/cli/utils/sql_expression_parser.rb

@@ -5,7 +5,19 @@ module Strata
       class ExpressionParser
         attr_reader :expression, :columns, :field_refs, :measure_refs, :dimension_refs, :functions
 
-        def initialize(expression, reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions)
+        # The identifier quote for ANSI SQL and any adapter whose quote setting is
+        # bracket-style: [Name] is Strata's field-reference syntax, so an adapter
+        # that quotes with brackets (SQL Server) quotes identifiers with double
+        # quotes in expressions instead.
+        ANSI_QUOTE = '"@exp"'
+
+        # +quote+ is the adapter's identifier quote template from its DWH settings
+        # ("@exp" wrapped in the warehouse's quote characters). Only that quote
+        # marks an identifier: on a backtick warehouse (MySQL, BigQuery, ...) a
+        # double-quoted span is a string literal, not a column.
+        def initialize(expression, reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions, quote: ANSI_QUOTE)
+          @open, @close = self.class.quote_pair(quote)
+          @raw = expression
           @expression = expression.downcase
           @reserved = reserved
           @aggregates = aggregates
@@ -46,7 +58,7 @@ module Strata
             stack = [] # one entry per open paren: is it an aggregate call?
             # Bracketed references are consumed atomically FIRST, so a parenthesis inside a
             # reference name ([Month(Date)]) cannot unbalance the stack.
-            remove_string_literals(@expression).scan(/\[([^\]]+)\]@d|\[[^\]]+\](?:@m)?|([a-z_][a-z0-9_]*)?\(|\)/) do
+            scrub(@expression).scan(/\[([^\]]+)\]@d|\[[^\]]+\](?:@m)?|([a-z_][a-z0-9_]*)?\(|\)/) do
               token = Regexp.last_match(0)
               if Regexp.last_match(1)
                 ref = Regexp.last_match(1).strip
@@ -64,6 +76,22 @@ module Strata
         end
 
         class << self
+          # The opening and closing identifier quote characters an adapter's quote
+          # template ("@exp", `@exp`, [@exp]) wraps around a name. Bracket quoting
+          # is Strata's field-reference syntax, so it falls back to ANSI quotes.
+          def quote_pair(template)
+            template = template.to_s
+            template = ANSI_QUOTE if template.strip.empty? || template.start_with?("[")
+            open, close = template.split("@exp", 2)
+            [open, (close.nil? || close.empty?) ? open : close]
+          end
+
+          # String literals: single-quoted always, double-quoted too on a
+          # warehouse whose identifier quote is something else (MySQL, BigQuery).
+          def literal_regex(open)
+            (open == '"') ? /'(?:[^']|'')*'/ : /'(?:[^']|'')*'|"(?:[^"]|"")*"/
+          end
+
           # Can this (resolved) SQL expression legally appear in a GROUP BY? Aggregates and
           # windows evaluate over the grouped rows, so an expression carrying either cannot —
           # the binder rejects it ("GROUP BY clause cannot contain aggregates").
@@ -86,16 +114,19 @@ module Strata
             sql.gsub(/(?<!")\b#{Regexp.quote(col)}\b(?!")/i, qualified)
           end
 
-          def parse(expression, reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions)
-            new(expression, reserved: reserved, aggregates: aggregates)
+          def parse(expression, reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions, quote: ANSI_QUOTE)
+            new(expression, reserved: reserved, aggregates: aggregates, quote: quote)
           end
         end
 
         private
 
         def parse
-          # Sanitize the expression first
-          sanitized = remove_string_literals(@expression)
+          # Quoted identifiers are collected from the original text -- their case
+          # is part of the name -- and scrubbed out of the working copy along with
+          # string literals, so nothing inside them reads as a function or column.
+          @quoted_identifiers = []
+          sanitized = scrub(@raw) { |ident| @quoted_identifiers << ident unless @quoted_identifiers.include?(ident) }.downcase
 
           matched_refs = []
           # Extract field references in bracketed notation — BEFORE scanning functions, so a
@@ -123,10 +154,7 @@ module Strata
           # grouping — which is what has_window_functions? reports.
           @windowed = sanitized.match?(/\bover\s*\(/)
 
-          # Extract quoted columns
-          @expression.scan(/"([^"]+)"/).flatten.each do |col|
-            @columns << col
-          end
+          @columns.concat(@quoted_identifiers)
 
           # Extract column references (alphanumeric with optional underscores)
           sanitized.scan(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b/).flatten.each do |col|
@@ -136,8 +164,21 @@ module Strata
           @wild = true if sanitized.match?(/\w+\(\s?\*\s?\)/)
         end
 
-        def remove_string_literals(expr)
-          expr.gsub(/'[^']*'/, "'__str__'")
+        # Replaces string literals with a placeholder literal and quoted
+        # identifiers with a numeric placeholder (yielding each identifier's
+        # name), leaving an expression whose remaining words are all bare
+        # references, keywords, or functions. Inside a quoted identifier a
+        # doubled quote character is an escaped quote.
+        def scrub(expr)
+          o, c = Regexp.quote(@open), Regexp.quote(@close)
+          expr.gsub(/#{self.class.literal_regex(@open)}|#{o}((?:[^#{c}]|#{c}#{c})+)#{c}/) do
+            if Regexp.last_match(1)
+              yield Regexp.last_match(1) if block_given?
+              "0"
+            else
+              "'__str__'"
+            end
+          end
         end
 
         def remove_matched_refs(sanitized, matched_refs)

data/lib/strata/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Strata
   module CLI
-    VERSION = "0.1.21"
+    VERSION = "0.1.22"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strata-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.22
 platform: ruby
 authors:
 - Ajo Abraham