strata-cli 0.1.4.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

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

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

@@ -105,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)
@@ -116,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/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?

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

@@ -126,9 +126,15 @@ module Strata
         end
 
         def handle_table_creation_interactive
-          return if all_tables.empty?
+          fetch_result = table_fetch_result
+          tables = fetch_result[:tables]
+          if tables.empty?
+            return handle_table_creation_without_connection if fetch_result[:failed]
 
-          selected_table = resolve_table_selection(nil)
+            return
+          end
+
+          selected_table = resolve_table_selection(tables, nil)
           return unless selected_table
 
           # For interactive, derive path from table name
@@ -191,21 +197,26 @@ module Strata
           schema_info = parsed[:schema] ? " in schema '#{parsed[:schema]}'" : ""
           say "\nCould not find table '#{table_name}'#{schema_info} in datasource '#{datasource_key}'.", :red
 
-          if prompt.yes?("Proceed anyway or cancel?")
-            proceed_with_table_creation(nil, parsed)
+          if prompt.yes?("Proceed with template-only file (no generated fields)?", default: true)
+            proceed_with_table_creation(nil, parsed, skip_field_editor: true)
           else
             say "Cancelled.", :yellow
           end
         end
 
-        def proceed_with_table_creation(selected_table, parsed)
+        def proceed_with_table_creation(selected_table, parsed, skip_field_editor: false)
           # If table not found, use parsed physical_name
           physical_table_name = selected_table || (parsed[:schema] ? "#{parsed[:schema]}.#{parsed[:physical_name]}" : parsed[:physical_name])
 
           model_config = prompt_model_config(parsed)
           return unless model_config[:name]
 
-          # Only fetch columns if we have a valid table
+          if skip_field_editor || selected_table.nil?
+            say "Skipping field generation. Template file will be created without fields.", :yellow
+            save_model_file(parsed, physical_table_name, [], model_config)
+            return
+          end
+
           columns = []
           if selected_table
             columns = fetch_columns(selected_table)
@@ -218,7 +229,6 @@ module Strata
             []
           end
 
-          # Interactive field editor
           result = run_field_editor(fields, physical_table_name, columns, model_config)
           return if result.nil?
 
@@ -235,16 +245,27 @@ module Strata
           save_model_file(parsed, physical_table_name, confirmed_fields, final_model_context)
         end
 
-        def resolve_table_selection(initial_filter)
+        def resolve_table_selection(tables, initial_filter)
           autocomplete = Autocomplete.new(prompt: prompt)
           autocomplete.select(
             MSG_SEARCH_TABLE,
-            all_tables,
+            tables,
             display_transform: ->(table) { TableFilter.display_name(table) },
             default_filter: initial_filter
           )
         end
 
+        def handle_table_creation_without_connection
+          say "\nConnection failed. You can still create a template-only table model.", :yellow
+          return unless prompt.yes?("Continue without fetching table metadata?", default: true)
+
+          table_path = prompt.ask("  Table path (e.g., games/event_details):")
+          return unless table_path
+
+          parsed = parse_table_path(table_path)
+          proceed_with_table_creation(nil, parsed, skip_field_editor: true)
+        end
+
         def prompt_model_config(parsed)
           # Default name should be the table name (without schema), not a display name
           # This matches the requirement: "The name and physical name will be event_details"
@@ -367,14 +388,15 @@ module Strata
             []
           end
 
-          unless valid_entities.include?(entity&.downcase)
-            valid_list = valid_entities.join(", ")
-            if operation == "swap" && entity&.downcase == "datasource"
-              raise Strata::CommandError, "Swap operation does not support 'datasource' entity type. Valid types: #{valid_list}"
-            else
-              raise Strata::CommandError, "Invalid entity type: #{entity}. Valid types for #{operation}: #{valid_list}"
-            end
+          return if valid_entities.include?(entity&.downcase)
+
+          valid_list = valid_entities.join(", ")
+          unless operation == "swap" && entity&.downcase == "datasource"
+            raise Strata::CommandError, "Invalid entity type: #{entity}. Valid types for #{operation}: #{valid_list}"
           end
+
+          raise Strata::CommandError,
+            "Swap operation does not support 'datasource' entity type. Valid types: #{valid_list}"
         end
 
         def validate_required_params(entity, from, to)
@@ -382,9 +404,9 @@ module Strata
           raise Strata::CommandError, "Missing required option: --from" if from.nil? || from.strip.empty?
           raise Strata::CommandError, "Missing required option: --to" if to.nil? || to.strip.empty?
 
-          if from.strip == to.strip
-            say "Warning: --from and --to have the same value. Migration will have no effect.", ColorHelper.warning
-          end
+          return unless from.strip == to.strip
+
+          say "Warning: --from and --to have the same value. Migration will have no effect.", ColorHelper.warning
         end
 
         def prompt_migration_hook(operation)