strata-cli 0.1.0.beta

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Strata
+  module CLI
+    # Shared module for table filtering and display name extraction
+    module TableFilter
+      # Extract display name from full table path
+      # e.g., "sales/analytics/customer" -> "customer"
+      # @param table_path [String] Full table path
+      # @return [String] Last element of the path
+      def self.display_name(table_path)
+        table_path.split("/").last || table_path
+      end
+
+      # Filter tables by pattern (case-insensitive)
+      # @param tables [Array<String>] List of table paths
+      # @param pattern [String] Search pattern
+      # @return [Array<String>] Filtered tables
+      def self.filter(tables, pattern)
+        return tables if pattern.nil? || pattern.empty?
+
+        regex = Regexp.new(pattern, Regexp::IGNORECASE)
+        tables.select { |table| table.match?(regex) || display_name(table).match?(regex) }
+      end
+
+      # Paginate array of items
+      # @param items [Array] Items to paginate
+      # @param page [Integer] Current page (1-indexed)
+      # @param per_page [Integer] Items per page
+      # @return [Array] Items for current page
+      def self.paginate(items, page: 1, per_page: 10)
+        start_idx = (page - 1) * per_page
+        end_idx = start_idx + per_page
+        items[start_idx...end_idx] || []
+      end
+
+      # Get total pages for pagination
+      # @param items [Array] Items to paginate
+      # @param per_page [Integer] Items per page
+      # @return [Integer] Total number of pages
+      def self.total_pages(items, per_page: 10)
+        return 1 if items.empty?
+
+        (items.length.to_f / per_page).ceil
+      end
+    end
+  end
+end

data/lib/strata/cli/main.rb

@@ -0,0 +1,71 @@
+require_relative "generators/project"
+require_relative "sub_commands/datasource"
+require_relative "sub_commands/deploy"
+require_relative "sub_commands/project"
+require_relative "sub_commands/table"
+require_relative "sub_commands/create"
+require_relative "sub_commands/audit"
+require_relative "helpers/description_helper"
+
+module Strata
+  module CLI
+    class Main < Thor
+      include Guard
+      extend Helpers::DescriptionHelper
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "version", "Prints this version of strata-cli"
+      def version
+        say VERSION
+      end
+
+      desc "init [PROJECT_NAME]", "Initializes a new Strata project. PROJECT_NAME is optional when using --source."
+      long_desc_from_file "init"
+      option :datasource, aliases: ["d"], type: :string, desc: "One of the supported data warehouse adapters.",
+        repeatable: true
+      option :source, aliases: ["s"], type: :string, desc: "URL of existing project"
+      option :api_key, aliases: ["a"], type: :string, desc: "Api Key. Required if initializing existing project."
+
+      def init(project_name = nil)
+        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
+        invoke Generators::Project, [project_name], options
+      end
+
+      desc "adapters", "Lists supported data warehouse adapters"
+      def adapters
+        out = " SUPPORTED ADAPTERS: \n\t#{DWH.adapters.keys.join("\n\t")}"
+        say out, ColorHelper.info
+      end
+
+      desc "datasource", "Manage project datasources"
+      subcommand "datasource", SubCommands::Datasource
+
+      desc "create", "Create semantic models (tables, relations)"
+      subcommand "create", SubCommands::Create
+
+      desc "table", "Manage semantic tables"
+      subcommand "table", SubCommands::Table
+
+      desc "audit", "Audit project configuration and models"
+      subcommand "audit", SubCommands::Audit
+
+      desc "deploy", "Deploy project to Strata server"
+      subcommand "deploy", SubCommands::Deploy
+
+      desc "project", "Manage project configuration"
+      subcommand "project", SubCommands::Project
+
+      # Creating aliases
+      map "t" => "table"
+      map "tbl" => "table"
+      map "ds" => "datasource"
+      map "a" => "audit"
+    end
+  end
+end

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

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require_relative "../guard"
+require_relative "../terminal"
+require_relative "../credentials"
+require_relative "../helpers/color_helper"
+require_relative "../helpers/datasource_helper"
+require_relative "../utils/yaml_import_resolver"
+require_relative "../utils/import_manager"
+require "yaml"
+require "pathname"
+
+module Strata
+  module CLI
+    module SubCommands
+      class Audit < Thor
+        include Thor::Actions
+        include Guard
+        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]
+
+        # Set default command so `strata audit` still works as `strata audit all`
+        default_command :all
+
+        desc "all", "Run all audit checks"
+        def all
+          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 }
+
+          report_results(results)
+        end
+
+        desc "syntax", "Check YAML syntax of configuration files"
+        def syntax
+          results = {yaml: run_check("Checking YAML syntax") { audit_yaml_syntax }}
+          report_results(results)
+        end
+
+        desc "models", "Check model definitions and schema structure"
+        def models
+          results = {models: run_check("Checking model definitions") { audit_models }}
+          report_results(results)
+        end
+
+        desc "connections", "Check data source connections"
+        def connections
+          results = {connections: run_check("Checking data source connections") { audit_connections }}
+          report_results(results)
+        end
+
+        private
+
+        def report_results(results)
+          if results.values.all?
+            # All checks passed - no need for additional message, spinners already show success
+          else
+            say "\n Some checks failed.", ColorHelper.error
+            exit(1)
+          end
+        end
+
+        def run_check(message)
+          failures = []
+          with_spinner(message) do
+            failures = yield
+            raise StandardError, "Check failed" if failures.any?
+          end
+          true
+        rescue
+          failures.each do |f|
+            msg = f.is_a?(Hash) ? "#{f[:file]}: #{f[:message]}" : f.to_s
+            say "  ✖ #{msg}", ColorHelper.error
+          end
+          false
+        end
+
+        def audit_yaml_syntax
+          files = Dir.glob("models/**/*.yml") + ["datasources.yml"].select { |f| File.exist?(f) }
+
+          failures = []
+          files.each do |file|
+            YAML.safe_load_file(file, permitted_classes: [Date, Time], aliases: true)
+          rescue Psych::SyntaxError => e
+            failures << {file: file, message: e.message}
+          rescue => e
+            failures << {file: file, message: e.message}
+          end
+          failures
+        end
+
+        def audit_models
+          failures = []
+          Dir.glob("models/**/*.yml").each do |file|
+            audit_model_file(file, failures)
+            audit_imports(file, failures)
+          end
+          failures
+        end
+
+        def audit_model_file(file, failures)
+          content = YAML.safe_load_file(file, permitted_classes: [Date, Time], aliases: true) || {}
+          return unless content.is_a?(Hash)
+
+          validate_structure(content, file, failures)
+
+          case model_type(file)
+          when :table
+            validate_table_model(content, file, failures)
+          when :relationship
+            validate_relationship_model(content, file, failures)
+          end
+        rescue
+          # Ignore errors here, they are handled in audit_yaml_syntax if needed
+          # or simply skipped if the file is unreadable
+        end
+
+        def model_type(file)
+          filename = File.basename(file)
+          if filename.start_with?("tbl.")
+            :table
+          elsif filename.start_with?("rel.")
+            :relationship
+          end
+        end
+
+        def validate_structure(content, file, failures)
+          content.keys.each 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_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_relationship_definitions(content, file, failures)
+        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?
+        end
+
+        def validate_table_fields(fields, file, failures)
+          unless fields.is_a?(Array)
+            failures << {file: file, message: "'fields' must be an array"}
+            return
+          end
+
+          fields.each_with_index do |field, idx|
+            unless field.is_a?(Hash) && field.key?("name")
+              failures << {file: file, message: "Field at index #{idx} missing 'name'"}
+            end
+          end
+        end
+
+        def validate_relationship_definitions(content, file, failures)
+          content.each do |key, definition|
+            next if key == "datasource"
+
+            unless definition.is_a?(Hash)
+              failures << {file: file, message: "Relationship '#{key}' is not a hash definition"}
+              next
+            end
+
+            validate_relationship_properties(key, definition, file, failures)
+          end
+        end
+
+        def validate_relationship_properties(name, definition, file, failures)
+          REQUIRED_KEYS_FOR_RELATIONSHIP_DEFINITION.each do |req|
+            failures << {file: file, message: "Relationship '#{name}' missing '#{req}'"} unless definition.key?(req)
+          end
+          validate_cardinality(name, definition["cardinality"], file, failures) if definition.key?("cardinality")
+        end
+
+        def validate_cardinality(name, cardinality, file, failures)
+          return if RELATIONSHIP_CARDINALITIES.include?(cardinality)
+
+          failures << {file: file, message: "Relationship '#{name}' has invalid cardinality '#{cardinality}'"}
+        end
+
+        def audit_connections
+          failures = []
+
+          unless File.exist?("datasources.yml")
+            failures << {file: "datasources.yml", message: "File not found"}
+            return failures
+          end
+
+          if datasources.empty?
+            failures << {file: "datasources.yml",
+                          message: "No datasources found. Run 'strata datasource add' to configure one."}
+            return failures
+          end
+
+          datasources.each_key do |ds_key|
+            adapter = create_adapter(ds_key)
+            adapter.test_connection(raise_exception: true)
+          rescue => e
+            failures << {
+              file: "datasources.yml",
+              message: "Connection failed for '#{ds_key}': #{e.message}"
+            }
+          end
+
+          failures
+        end
+
+        def audit_imports(file, failures)
+          content = YAML.safe_load_file(file, permitted_classes: [Date, Time], aliases: true) || {}
+          return unless content.is_a?(Hash) && content["imports"]
+
+          project_path = Dir.pwd
+          base_dir = File.dirname(file)
+
+          content["imports"].each do |import_path|
+            # Validate import path is relative (will raise InvalidImportPathError if absolute)
+            Utils::ImportManager.validate_import_path(import_path)
+
+            # Validate that relative path resolves to an existing file
+            resolved_path = File.expand_path(import_path, base_dir)
+            unless File.exist?(resolved_path)
+              failures << {file: file, message: "Import file not found: #{import_path}"}
+              next
+            end
+
+            resolved_path = Utils::ImportManager.resolve_with_fallback(import_path, base_dir, project_path)
+            imported_content = YAML.safe_load_file(resolved_path, permitted_classes: [Date, Time], aliases: true) || {}
+
+            unless imported_content.is_a?(Hash)
+              failures << {file: file, message: "Imported file '#{import_path}' does not contain valid YAML hash"}
+              next
+            end
+
+            if model_type(file) == :table && imported_content["fields"]
+              validate_table_fields(imported_content["fields"], file, failures)
+            end
+          rescue Strata::InvalidImportPathError => e
+            failures << {file: file, message: e.message}
+          rescue Strata::MissingImportError
+            failures << {file: file, message: "Import file not found: #{import_path}"}
+          rescue Strata::CircularImportError => e
+            failures << {file: file, message: "Circular import detected: #{e.message}"}
+          rescue => e
+            failures << {file: file, message: "Error processing import '#{import_path}': #{e.message}"}
+          end
+        end
+      end
+    end
+  end
+end