strata-cli 0.1.3.beta → 0.1.5.beta

data/lib/strata/cli/generators/project.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "group"
 require_relative "datasource"
 require_relative "../helpers/project_helper"
@@ -6,185 +8,199 @@ require "faraday"
 require "json"
 require "uri"
 
-module Strata::CLI
-  module Generators
-    class Project < Group
-      include API::ConnectionErrorHandler
+module Strata
+  module CLI
+    module Generators
+      class Project < Group
+        include API::ConnectionErrorHandler
+
+        BASE_SERVER_URL = "http://localhost:3000"
+
+        argument :name, type: :string, required: false, desc: "The name of the project. Optional when using --source."
+        class_option :datasource, type: :string, repeatable: true
+        class_option :source, type: :string
+        class_option :api_key, type: :string
+
+        desc "Generates a new Strata project."
+
+        def validate_options
+          if options.key?(:source)
+            unless options.key?(:api_key)
+              raise Strata::CommandError,
+                "API key is required when using --source option. Use --api-key option."
+            end
+          else
+            unless @name && !@name.to_s.strip.empty?
+              raise Strata::CommandError,
+                "PROJECT_NAME is required when not using --source option."
+            end
+          end
+        end
 
-      BASE_SERVER_URL = "http://localhost:3000"
+        def fetch_and_clone_if_available
+          return unless options.key?(:source)
 
-      argument :name, type: :string, required: false, desc: "The name of the project. Optional when using --source."
-      class_option :datasource, type: :string, repeatable: true
-      class_option :source, type: :string
-      class_option :api_key, type: :string
+          project_info = fetch_project_info
+          @project_id = project_info["id"]
+          @project_info = project_info
 
-      desc "Generates a new Strata project."
+          return unless project_info["git_url"] && !project_info["git_url"].empty?
 
-      def validate_options
-        if options.key?(:source)
-          raise Strata::CommandError, "API key is required when using --source option. Use --api-key option." unless options.key?(:api_key)
-        else
-          raise Strata::CommandError, "PROJECT_NAME is required when not using --source option." unless @name && !@name.to_s.strip.empty?
+          @cloned_from_git = true
+          clone_project(project_info["git_url"])
         end
-      end
-
-      def fetch_and_clone_if_available
-        return unless options.key?(:source)
-
-        project_info = fetch_project_info
-        @project_id = project_info["id"]
-        @project_info = project_info
 
-        return unless project_info["git_url"] && !project_info["git_url"].empty?
+        def create_project_structure
+          return if cloned_from_git?
 
-        @cloned_from_git = true
-        clone_project(project_info["git_url"])
-      end
+          empty_directory uid
+          empty_directory File.join(uid, "models")
+          empty_directory File.join(uid, "tests")
+        end
 
-      def create_project_structure
-        return if cloned_from_git?
+        def create_strata_config_file
+          template "strata.yml", "#{uid}/.strata"
+        end
 
-        empty_directory uid
-        empty_directory File.join(uid, "models")
-        empty_directory File.join(uid, "tests")
-      end
+        def create_project_file
+          return if cloned_from_git?
 
-      def create_strata_config_file
-        template "strata.yml", "#{uid}/.strata"
-      end
+          template "project.yml", "#{uid}/project.yml"
+        end
 
-      def create_project_file
-        return if cloned_from_git?
+        def persist_project_id_if_needed
+          # Persist project_id after project.yml exists (either from clone or creation)
+          return unless @project_id
 
-        template "project.yml", "#{uid}/project.yml"
-      end
+          project_yml_path = File.join(uid, "project.yml")
+          return unless File.exist?(project_yml_path)
 
-      def persist_project_id_if_needed
-        # Persist project_id after project.yml exists (either from clone or creation)
-        return unless @project_id
+          persist_project_id_to_project_yml
+        end
 
-        project_yml_path = File.join(uid, "project.yml")
-        return unless File.exist?(project_yml_path)
+        def create_datasources_file
+          return if cloned_from_git?
 
-        persist_project_id_to_project_yml
-      end
+          template "datasources.yml", "#{uid}/datasources.yml"
 
-      def create_datasources_file
-        return if cloned_from_git?
+          return unless options.key?(:datasource)
 
-        template "datasources.yml", "#{uid}/datasources.yml"
+          options[:datasource].each do |ds|
+            raise DWH::ConfigError, "Unsupported datasource #{ds}" unless DWH.adapter?(ds.to_sym)
 
-        return unless options.key?(:datasource)
+            Datasource.new([ds.downcase.strip], options.merge({"path" => uid})).invoke_all
+          end
+        end
 
-        options[:datasource].each do |ds|
-          raise DWH::ConfigError, "Unsupported datasource #{ds}" unless DWH.adapter?(ds.to_sym)
+        def initialize_git
+          return if cloned_from_git?
 
-          Datasource.new([ds.downcase.strip], options.merge({"path" => uid})).invoke_all
+          inside uid do
+            run "git init", verbose: false, capture: true
+            create_file ".gitignore", ".strata\n"
+          end
         end
-      end
 
-      def initialize_git
-        return if cloned_from_git?
+        def setup_datasource
+          return if cloned_from_git?
+          return if options.key?(:datasource) # Already specified via CLI option
+
+          say "\n", :white
+          say_status :setup, "Let's configure your first datasource", :cyan
 
-        inside uid do
-          run "git init", verbose: false, capture: true
-          create_file ".gitignore", ".strata\n"
+          # Change into the project directory and run the existing add command
+          inside(uid) do
+            require_relative "../sub_commands/datasource"
+            SubCommands::Datasource.new.add
+          end
         end
-      end
 
-      def setup_datasource
-        return if cloned_from_git?
-        return if options.key?(:datasource) # Already specified via CLI option
+        def completion_message
+          say "\n✔ Strata project '#{uid}' is ready!", :green
+          say "\nNext steps:", :yellow
+          say "  1. cd #{uid}", :cyan
+          say "  2. strata datasource add      # To add more datasources", :cyan
+          say "  3. strata create table      # Start adding tables", :cyan
+          say "\n"
+        end
 
-        say "\n", :white
-        say_status :setup, "Let's configure your first datasource", :cyan
+        private
 
-        # Change into the project directory and run the existing add command
-        inside(uid) do
-          require_relative "../sub_commands/datasource"
-          SubCommands::Datasource.new.add
+        def cloned_from_git?
+          @cloned_from_git ||= false
         end
-      end
 
-      def completion_message
-        say "\n✔ Strata project '#{uid}' is ready!", :green
-        say "\nNext steps:", :yellow
-        say "  1. cd #{uid}", :cyan
-        say "  2. strata datasource add      # To add more datasources", :cyan
-        say "  3. strata create table      # Start adding tables", :cyan
-        say "\n"
-      end
+        def fetch_project_info
+          conn = Faraday.new(url: options[:source]) do |f|
+            f.request :authorization, "Bearer", options[:api_key]
+            f.response :json
+          end
 
-      private
+          response = with_connection_error_handling(options[:source]) do
+            conn.get
+          end
 
-      def cloned_from_git?
-        @cloned_from_git ||= false
-      end
+          unless response.success?
+            raise Strata::CommandError,
+              "Failed to fetch project info from #{options[:source]}. Status: #{response.status}"
+          end
 
-      def fetch_project_info
-        conn = Faraday.new(url: options[:source]) do |f|
-          f.request :authorization, "Bearer", options[:api_key]
-          f.response :json
+          response.body
         end
 
-        response = with_connection_error_handling(options[:source]) do
-          conn.get
-        end
+        def clone_project(git_url)
+          say_status :clone, "Cloning project from #{git_url}", :green
+          run "git clone #{git_url} #{uid}", verbose: false, capture: true
+
+          raise Strata::CommandError, "Failed to clone repository from #{git_url}" unless File.directory?(uid)
 
-        unless response.success?
-          raise Strata::CommandError,
-            "Failed to fetch project info from #{options[:source]}. Status: #{response.status}"
+          say_status :success, "Project cloned successfully", :green
         end
 
-        response.body
-      end
+        def persist_project_id_to_project_yml
+          return unless @project_id
 
-      def clone_project(git_url)
-        say_status :clone, "Cloning project from #{git_url}", :green
-        run "git clone #{git_url} #{uid}", verbose: false, capture: true
+          project_yml_path = File.join(uid, "project.yml")
+          Helpers::ProjectHelper.persist_project_id_to_yml(@project_id, project_yml_path: project_yml_path)
+        end
 
-        raise Strata::CommandError, "Failed to clone repository from #{git_url}" unless File.directory?(uid)
+        def uid
+          @uid ||= if options.key?(:source) && @project_info
+            @project_info["uid"] || options[:source].split("/").last
+          else
+            Utils.url_safe_str(name)
+          end
+        end
 
-        say_status :success, "Project cloned successfully", :green
-      end
+        def name
+          # Use name from server if available (when using --source), otherwise use argument
+          return @project_info["name"] if options.key?(:source) && @project_info
 
-      def persist_project_id_to_project_yml
-        return unless @project_id
+          @name
+        end
 
-        project_yml_path = File.join(uid, "project.yml")
-        Helpers::ProjectHelper.persist_project_id_to_yml(@project_id, project_yml_path: project_yml_path)
-      end
+        def server_url
+          return options[:source] if options.key?(:source)
 
-      def uid
-        @uid ||= if options.key?(:source) && @project_info
-          @project_info["uid"] || options[:source].split("/").last
-        else
-          Utils.url_safe_str(name)
+          BASE_SERVER_URL
         end
-      end
 
-      def name
-        # Use name from server if available (when using --source), otherwise use argument
-        return @project_info["name"] if options.key?(:source) && @project_info
-        @name
-      end
+        def description
+          return @project_info["description"] if options.key?(:source) && @project_info
 
-      def server_url
-        return options[:source] if options.key?(:source)
-        BASE_SERVER_URL
-      end
+          nil
+        end
 
-      def description
-        return @project_info["description"] if options.key?(:source) && @project_info
-        nil
-      end
+        def production_branch
+          if options.key?(:source) && @project_info && @project_info["production_branch"]
+            return @project_info["production_branch"]
+          end
 
-      def production_branch
-        return @project_info["production_branch"] if options.key?(:source) && @project_info && @project_info["production_branch"]
-        "main"
-      end
+          "main"
+        end
 
-      attr_reader :project_id
+        attr_reader :project_id
+      end
     end
   end
 end

data/lib/strata/cli/generators/table.rb

@@ -108,6 +108,9 @@ module Strata
               "data_type" => normalized[:data_type]
             }
 
+            synonyms = normalized[:synonyms]
+            field_hash["synonyms"] = synonyms if synonyms.is_a?(Array) && !synonyms.empty?
+
             # Build expression with proper nested format
             expr = normalized[:expression]
             field_hash["expression"] = {

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

@@ -96,6 +96,12 @@ fields:
   #     array: true|false  (optional)
   #     sql: my_field_column (Required)
   #
+  #   # Optional: Alternative names for this field. Helps AI and search
+  #   # find this field when users refer to it by different names.
+  #   synonyms:
+  #     - alt name one
+  #     - alt name two
+  #
   #   # Optional: Exclude certain dimnesions from the group by/filter
   #   exclusion_type: exclude|exclude_all_except|exclude_all
   #   exclusions: # (Required when exclusion type is set and isnt exclude_all)

data/lib/strata/cli/guard.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "utils"
 module Strata
   module CLI

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

@@ -4,6 +4,7 @@ require "tty-prompt"
 require_relative "datasource_helper"
 require_relative "color_helper"
 require_relative "prompts"
+require_relative "../error_reporter"
 
 module Strata
   module CLI
@@ -23,18 +24,36 @@ module Strata
           @datasource_key ||= resolve_datasource(prompt: prompt)
         end
 
-        def all_tables
-          @all_tables ||= begin
+        def table_fetch_result
+          @table_fetch_result ||= begin
             tables = with_spinner("Fetching tables from #{datasource_key}...") { adapter.tables }
             if tables.empty?
               # Assuming Prompts and ColorHelper are available in the class or via module
               say Prompts::MSG_NO_TABLES_FOUND % datasource_key, ColorHelper.warning
-              []
+              {tables: [], failed: false}
+            else
+              {tables: tables, failed: false}
+            end
+          rescue => e
+            ErrorReporter.log_error(e, context: "create table: failed fetching tables for '#{datasource_key}'")
+
+            if ErrorReporter.connection_error?(e)
+              say "Could not connect to datasource '#{datasource_key}'.", ColorHelper.warning
             else
-              tables
+              say "Could not fetch tables from datasource '#{datasource_key}'.", ColorHelper.warning
+              say "Reason: #{ErrorReporter.user_message_for(e)}", ColorHelper.warning
             end
+
+            say "Hint: verify credentials/settings and run 'strata datasource test #{datasource_key}'.",
+              ColorHelper.info
+            say "Details logged to '#{ErrorReporter.log_relative_path}'.", ColorHelper.info
+            {tables: [], failed: true}
           end
         end
+
+        def all_tables
+          table_fetch_result[:tables]
+        end
       end
     end
   end

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

@@ -42,9 +42,26 @@ module Strata
         config = ds_config(ds_key).merge(Credentials.fetch(ds_key))
         adapter_sym = config["adapter"].to_sym
         ensure_adapter_driver_gems!(adapter_sym)
+
+        # CLI only performs read operations (test, tables, metadata).
+        # Use read-only mode for file-based databases to avoid lock conflicts.
+        apply_readonly_mode(adapter_sym, config)
+
         DWH.create(adapter_sym, config)
       end
 
+      def apply_readonly_mode(adapter_sym, config)
+        case adapter_sym
+        when :duckdb
+          config["duck_config"] ||= {}
+          config["duck_config"]["access_mode"] = "READ_ONLY"
+        when :sqlite
+          config["readonly"] = true
+        end
+        # Client-server databases (postgres, mysql, snowflake, etc.)
+        # don't need special handling - no file lock issues
+      end
+
       def ensure_adapter_driver_gems!(adapter_sym)
         required = ADAPTER_DRIVER_GEMS.fetch(adapter_sym, [])
         return if required.empty?
@@ -88,6 +105,22 @@ module Strata
         datasources[ds_key]
       end
 
+      def resolve_datasource_value(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        normalized = value.to_s.downcase.strip
+
+        # Match by key first
+        return value if datasources.key?(normalized)
+
+        # Match by name (case-insensitive)
+        datasources.each do |key, config|
+          return key if config.is_a?(Hash) && config["name"].to_s.downcase.strip == normalized
+        end
+
+        nil
+      end
+
       private
 
       def validate_datasource(ds_key)
@@ -99,7 +132,7 @@ module Strata
       end
 
       def datasources
-        @datasources_cache ||= begin
+        @datasources ||= begin
           YAML.safe_load_file("datasources.yml", permitted_classes: [Date, Time], aliases: true) || {}
         rescue Errno::ENOENT
           {}

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Strata
   module CLI
     module Helpers

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

@@ -46,6 +46,34 @@ module Strata
           end
         end
 
+        # Persists server URL to project.yml (updates existing or appends)
+        def persist_server_to_project_yml(server, project_yml_path: "project.yml")
+          return false unless server && !server.to_s.strip.empty?
+          return false unless File.exist?(project_yml_path)
+
+          project_yml_content = File.read(project_yml_path)
+
+          begin
+            if /^server:\s*.+$/m.match?(project_yml_content)
+              updated_content = project_yml_content.gsub(/^(\s*)server:\s*.+$/, "\\1server: #{server}")
+              File.write(project_yml_path, updated_content)
+            else
+              File.open(project_yml_path, "a") do |f|
+                f.puts "\n" unless project_yml_content.end_with?("\n")
+                f.puts "server: #{server}"
+              end
+            end
+
+            true
+          rescue Errno::EACCES => e
+            raise Strata::CommandError, "Permission denied writing to #{project_yml_path}: #{e.message}"
+          rescue Errno::ENOSPC => e
+            raise Strata::CommandError, "Disk full: #{e.message}"
+          rescue => e
+            raise Strata::CommandError, "Failed to write to #{project_yml_path}: #{e.message}"
+          end
+        end
+
         # Persists git URL to project.yml file if missing
         def persist_git_url_if_missing(project_yml_path: "project.yml")
           return false unless File.exist?(project_yml_path)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Strata
   module CLI
     module Prompts

data/lib/strata/cli/main.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "generators/project"
 require_relative "sub_commands/datasource"
 require_relative "sub_commands/deploy"
@@ -33,7 +35,9 @@ module Strata
         unless project_name || options[:source]
           raise Strata::CommandError, "PROJECT_NAME is required when not using --source option."
         end
-        say_status :started, "Creating #{project_name || "project from source"} - #{options[:datasource]}", ColorHelper.info
+
+        say_status :started, "Creating #{project_name || "project from source"} - #{options[:datasource]}",
+          ColorHelper.info
         invoke Generators::Project, [project_name], options
       end
 

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

@@ -19,10 +19,10 @@ module Strata
         include Terminal
         include DatasourceHelper
 
-        REQUIRED_KEYS_FOR_TABLE_MODEL = %w[name physical_name fields datasource]
-        REQUIRED_KEYS_FOR_RELATIONSHIP_MODEL = ["datasource"]
-        REQUIRED_KEYS_FOR_RELATIONSHIP_DEFINITION = %w[left right sql cardinality]
-        RELATIONSHIP_CARDINALITIES = %w[one_to_one one_to_many many_to_one many_to_many]
+        REQUIRED_KEYS_FOR_TABLE_MODEL = %w[name physical_name fields 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 many_to_many].freeze
 
         # Set default command so `strata audit` still works as `strata audit all`
         default_command :all
@@ -131,21 +131,35 @@ module Strata
         end
 
         def validate_structure(content, file, failures)
-          content.keys.each do |k|
+          content.each_key do |k|
             failures << {file: file, message: "Top level key #{k} is not a string"} unless k.is_a?(String)
           end
         end
 
         def validate_table_model(content, file, failures)
           validate_required_keys(content, file, REQUIRED_KEYS_FOR_TABLE_MODEL, failures)
+          validate_datasource_reference(content, file, failures)
           validate_table_fields(content["fields"], file, failures) if content.key?("fields")
         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)
           validate_relationship_definitions(content, file, failures)
         end
 
+        def validate_datasource_reference(content, file, failures)
+          ds_value = content["datasource"]
+          return if ds_value.nil? || ds_value.to_s.strip.empty?
+
+          return if resolve_datasource_value(ds_value)
+
+          failures << {
+            file: file,
+            message: "Datasource '#{ds_value}' not found. Must match a key or name in datasources.yml"
+          }
+        end
+
         def validate_required_keys(content, file, required_keys, failures)
           missing = required_keys - content.keys
           failures << {file: file, message: "Missing required keys: #{missing.join(", ")}"} if missing.any?