strata-cli 0.1.0.beta

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

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require_relative "../guard"
+require_relative "../terminal"
+require_relative "../ui/autocomplete"
+require_relative "../ui/field_editor"
+require_relative "../credentials"
+require_relative "../helpers/table_filter"
+require_relative "../ai/services/table_generator"
+require_relative "../helpers/color_helper"
+require_relative "../helpers/prompts"
+require_relative "../helpers/description_helper"
+require_relative "../helpers/command_context"
+require "tty-prompt"
+require "tty-spinner"
+require "yaml"
+require "dwh"
+require "fileutils"
+
+module Strata
+  module CLI
+    module SubCommands
+      class Create < Thor
+        include Guard
+        include Terminal
+        include Prompts
+        include Thor::Actions
+        include Helpers::CommandContext
+        extend Helpers::DescriptionHelper
+
+        desc "table TABLE_PATH", "Create a semantic table model"
+        long_desc_from_file("create/table")
+
+        method_option :datasource, aliases: "-d", type: :string, required: false,
+          desc: "Datasource key from datasources.yml"
+
+        def table(table_path = nil)
+          return unless datasource_key
+
+          # If table_path provided, skip search for speed
+          if table_path
+            handle_table_creation_with_path(table_path)
+          else
+            handle_table_creation_interactive
+          end
+        end
+
+        desc "relation RELATION_PATH", "Create a relation (join) definition file"
+        long_desc_from_file("create/relation")
+
+        method_option :datasource, aliases: "-d", type: :string, required: false,
+          desc: "Datasource key from datasources.yml"
+
+        def relation(relation_path)
+          return unless datasource_key
+
+          create_relation_file(relation_path)
+        end
+
+        desc "migration SUBCOMMAND(rename or swap)", "Create migration files (rename or swap)"
+        long_desc_from_file "create/migration"
+        method_option :entity, aliases: "-e", type: :string, required: false,
+          desc: "Entity type: dimension, measure, table, or datasource"
+        method_option :from, aliases: "-f", type: :string, required: false,
+          desc: "Current/source entity name"
+        method_option :to, aliases: "-t", type: :string, required: false,
+          desc: "New/target entity name"
+
+        def migration(subcommand)
+          case subcommand
+          when "rename"
+            migration_rename
+          when "swap"
+            migration_swap
+          else
+            raise Strata::CommandError, "Unknown migration subcommand: #{subcommand}. Use 'rename' or 'swap'."
+          end
+        end
+
+        desc "migration rename", "Create a migration file to rename an entity"
+        method_option :entity, aliases: "-e", type: :string, required: true,
+          desc: "Entity type: dimension, measure, table, or datasource"
+        method_option :from, aliases: "-f", type: :string, required: true,
+          desc: "Current entity name"
+        method_option :to, aliases: "-t", type: :string, required: true,
+          desc: "New entity name"
+
+        def migration_rename
+          validate_entity_type(options[:entity], "rename")
+          validate_required_params(options[:entity], options[:from], options[:to])
+
+          hook = prompt_migration_hook("rename")
+          create_rename_migration(options[:entity], options[:from], options[:to], hook)
+        end
+
+        desc "migration swap", "Create a migration file to swap entity references"
+        method_option :entity, aliases: "-e", type: :string, required: true,
+          desc: "Entity type: dimension, measure, or table"
+        method_option :from, aliases: "-f", type: :string, required: true,
+          desc: "Source entity name"
+        method_option :to, aliases: "-t", type: :string, required: true,
+          desc: "Target entity name"
+
+        def migration_swap
+          validate_entity_type(options[:entity], "swap")
+          validate_required_params(options[:entity], options[:from], options[:to])
+
+          hook = prompt_migration_hook("swap")
+          create_swap_migration(options[:entity], options[:from], options[:to], hook)
+        end
+
+        private
+
+        def handle_table_creation_with_path(table_path)
+          # Parse the path to extract schema, physical name, and model path
+          parsed = parse_table_path(table_path)
+
+          # Try to find the table in the database
+          table_found = find_table_in_database(parsed[:physical_name], parsed[:schema])
+
+          if table_found
+            proceed_with_table_creation(table_found, parsed)
+          else
+            handle_table_not_found(parsed)
+          end
+        end
+
+        def handle_table_creation_interactive
+          return if all_tables.empty?
+
+          selected_table = resolve_table_selection(nil)
+          return unless selected_table
+
+          # For interactive, derive path from table name
+          default_path = TableFilter.display_name(selected_table).downcase.gsub(/\s+/, "_")
+          table_path = prompt.ask("  Table path (e.g., games/event_details):", default: default_path)
+          return unless table_path
+
+          parsed = parse_table_path(table_path)
+          proceed_with_table_creation(selected_table, parsed)
+        end
+
+        def parse_table_path(path)
+          # Examples:
+          # "call_center" -> { model_path: "call_center", physical_name: "call_center", schema: nil }
+          # "games/event_details" -> { model_path: "games/event_details", physical_name: "event_details", schema: nil }
+          # "contact/dse.call_center_d" -> { model_path: "contact/dse.call_center_d", physical_name: "call_center_d", schema: "dse" }
+          # "contact/help_center/visits" -> { model_path: "contact/help_center/visits", physical_name: "visits", schema: nil }
+
+          path_parts = path.split("/")
+          last_part = path_parts.last
+
+          # Check if last part contains schema (e.g., "dse.call_center_d")
+          schema = nil
+          physical_name = last_part
+
+          if last_part.include?(".")
+            parts = last_part.split(".", 2)
+            schema = parts[0]
+            physical_name = parts[1]
+          end
+
+          {
+            model_path: path,
+            physical_name: physical_name.downcase,
+            schema: schema&.downcase
+          }
+        end
+
+        def find_table_in_database(physical_name, schema)
+          # Try to fetch metadata directly (skip table list for speed when path provided)
+          qualifiers = schema ? {schema: schema} : {}
+          qualified_name = schema ? "#{schema}.#{physical_name}" : physical_name
+
+          begin
+            with_spinner("Checking table existence...") do
+              table_metadata = adapter.metadata(physical_name, **qualifiers)
+              # If metadata returns a table with no columns, the table doesn't exist
+              # (some adapters return empty table instead of raising error)
+              raise StandardError, "Table not found" if table_metadata.columns.empty?
+
+              qualified_name
+            end
+          rescue
+            nil
+          end
+        end
+
+        def handle_table_not_found(parsed)
+          table_name = parsed[:physical_name]
+          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)
+          else
+            say "Cancelled.", :yellow
+          end
+        end
+
+        def proceed_with_table_creation(selected_table, parsed)
+          # 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
+          columns = []
+          if selected_table
+            columns = fetch_columns(selected_table)
+            say "  Found #{columns.length} columns\n", :cyan
+          end
+
+          fields = if columns.any?
+            generate_fields(physical_table_name, columns, model_config)
+          else
+            []
+          end
+
+          # Interactive field editor
+          result = run_field_editor(fields, physical_table_name, columns, model_config)
+          return if result.nil?
+
+          confirmed_fields = result[:fields]
+          final_model_context = result[:model_context]
+
+          if confirmed_fields.empty?
+            say MSG_NO_FIELDS_CONFIRMED, :yellow
+            return unless prompt.yes?(MSG_CONTINUE_NO_FIELDS)
+          else
+            say MSG_FIELDS_CONFIRMED % confirmed_fields.length, :cyan
+          end
+
+          save_model_file(parsed, physical_table_name, confirmed_fields, final_model_context)
+        end
+
+        def resolve_table_selection(initial_filter)
+          autocomplete = Autocomplete.new(prompt: prompt)
+          autocomplete.select(
+            MSG_SEARCH_TABLE,
+            all_tables,
+            display_transform: ->(table) { TableFilter.display_name(table) },
+            default_filter: initial_filter
+          )
+        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"
+          default_table_name = parsed[:physical_name]
+
+          {
+            name: prompt.ask(MSG_MODEL_DISPLAY_NAME, default: default_table_name),
+            description: prompt.ask(MSG_MODEL_DESCRIPTION, default: "")
+          }
+        end
+
+        def fetch_columns(table_name)
+          with_spinner("Fetching column metadata...") do
+            # Parse qualified table name if present (e.g., "schema.table" -> table name and schema)
+            qualifiers = {}
+
+            if table_name.include?(".")
+              parts = table_name.split(".", 2)
+              qualifiers[:schema] = parts.first
+            end
+
+            metadata = adapter.metadata(table_name, **qualifiers)
+            metadata.columns.map { |c| {name: c.name, type: c.data_type} }
+          end
+        end
+
+        def generate_fields(table, columns, context)
+          generator = AI::Services::TableGenerator.new
+
+          if generator.ai_available?
+            with_spinner("Analyzing table columns...") do
+              generator.call(
+                table_name: table,
+                columns: columns,
+                datasource: datasource_key,
+                user_context: context
+              )
+            end
+          else
+            with_spinner("Generating basic field definitions...") do
+              generator.call(
+                table_name: table,
+                columns: columns,
+                datasource: datasource_key
+              )
+            end
+          end
+        end
+
+        def run_field_editor(fields, table, columns, context)
+          editor = FieldEditor.new(
+            fields,
+            prompt: prompt,
+            table_context: {
+              table_name: table,
+              columns: columns,
+              datasource: datasource_key
+            },
+            model_context: context
+          )
+          result = editor.run
+
+          if result.nil?
+            say "\nCancelled.", :yellow
+            nil
+          else
+            result
+          end
+        end
+
+        def save_model_file(parsed, physical_table_name, fields, context)
+          # Build output path based on parsed model_path
+          # e.g., "games/event_details" -> "models/games/tbl.event_details.yml"
+          # e.g., "contact/dse.call_center_d" -> "models/contact/tbl.dse.call_center_d.yml"
+          # Filenames are standardized to lowercase
+
+          path_parts = parsed[:model_path].split("/")
+          last_part = path_parts.last.downcase
+
+          if path_parts.length > 1
+            subdir = path_parts[0..-2].join("/")
+            output_path = "models/#{subdir}/tbl.#{last_part}.yml"
+          else
+            output_path = "models/tbl.#{last_part}.yml"
+          end
+
+          # Extract physical name (without schema for the name field, but keep full for physical_name)
+          parsed[:physical_name]
+          parsed[:physical_name] # Use just the table name, not schema
+
+          options_with_name = options.merge(name: context[:name])
+
+          require_relative "../generators/table"
+          gen = Generators::Table.new(
+            [parsed[:model_path], datasource_key, physical_table_name, fields, context],
+            options_with_name
+          )
+          gen.invoke_all
+
+          say MSG_CREATED_MODEL % output_path, :green
+          say MSG_EDIT_MODEL_HINT, :yellow
+        end
+
+        def create_relation_file(relation_path)
+          require_relative "../generators/relation"
+
+          relation_generator = Generators::Relation.new([relation_path, datasource_key])
+          relation_generator.invoke_all
+
+          say "\n💡 Edit the file to define your joins between tables", :yellow
+        end
+
+        def validate_entity_type(entity, operation)
+          valid_entities = case operation
+          when "rename"
+            %w[dimension measure table datasource]
+          when "swap"
+            %w[dimension measure table]
+          else
+            []
+          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
+          end
+        end
+
+        def validate_required_params(entity, from, to)
+          raise Strata::CommandError, "Missing required option: --entity" if entity.nil? || entity.strip.empty?
+          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
+        end
+
+        def prompt_migration_hook(operation)
+          hook_options = Prompts::MIGRATION_HOOK_OPTIONS
+          default_key = Prompts.default_migration_hook(operation)
+
+          prompt.select("Migration hook:", hook_options, default: default_key)
+        end
+
+        def create_rename_migration(entity, from, to, hook = "pre")
+          require_relative "../generators/migration"
+
+          migration_generator = Generators::Migration.new(
+            ["rename", entity, from, to],
+            {hook: hook}
+          )
+          migration_generator.invoke_all
+        end
+
+        def create_swap_migration(entity, from, to, hook = "post")
+          require_relative "../generators/migration"
+
+          migration_generator = Generators::Migration.new(
+            ["swap", entity, from, to],
+            {hook: hook}
+          )
+          migration_generator.invoke_all
+        end
+      end
+    end
+  end
+end