nvoi 0.1.8 → 0.2.1

data/lib/nvoi/configuration/builder.rb

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+
+module Nvoi
+  module Configuration
+    # Builder for constructing and modifying config data hashes
+    # Replaces ConfigApi with a cleaner, chainable interface
+    class Builder
+      COMPUTE_PROVIDERS = %w[hetzner aws scaleway].freeze
+      DOMAIN_PROVIDERS = %w[cloudflare].freeze
+      DATABASE_ADAPTERS = %w[postgres postgresql mysql sqlite sqlite3].freeze
+
+      attr_reader :data
+
+      def initialize(data = nil)
+        @data = data || { "application" => {} }
+      end
+
+      # ─── Class Methods ───
+
+      def self.from_hash(data)
+        new(data)
+      end
+
+      def self.init(name:, environment: "production")
+        raise ArgumentError, "name is required" if name.blank?
+
+        master_key = Utils::Crypto.generate_key
+        private_key, public_key = Utils::ConfigLoader.generate_keypair
+
+        builder = new
+        builder.name(name)
+        builder.environment(environment)
+        builder.ssh_keys(private_key, public_key)
+
+        yaml = YAML.dump(builder.to_h)
+        encrypted_config = Utils::Crypto.encrypt(yaml, master_key)
+
+        Result::Init.new(
+          config: encrypted_config,
+          master_key:,
+          ssh_public_key: public_key
+        )
+      rescue ArgumentError => e
+        Result::Init.new(error_type: :invalid_args, error_message: e.message)
+      rescue Errors::ConfigError => e
+        Result::Init.new(error_type: :config_error, error_message: e.message)
+      end
+
+      # ─── Basic Setters ───
+
+      def name(n)
+        app["name"] = n.to_s
+        self
+      end
+
+      def environment(e)
+        app["environment"] = e.to_s
+        self
+      end
+
+      def ssh_keys(private_key, public_key)
+        app["ssh_keys"] = {
+          "private_key" => private_key,
+          "public_key" => public_key
+        }
+        self
+      end
+
+      # ─── Compute Provider ───
+
+      def compute_provider(provider, **opts)
+        validate_presence!(provider, "provider")
+        validate_inclusion!(provider.to_s, COMPUTE_PROVIDERS, "provider")
+
+        app["compute_provider"] = { provider.to_s => build_compute_config(provider.to_s, opts) }
+        wrap_success
+      end
+
+      def remove_compute_provider
+        app["compute_provider"] = {}
+        wrap_success
+      end
+
+      # ─── Domain Provider ───
+
+      def domain_provider(provider, **opts)
+        validate_presence!(provider, "provider")
+        validate_inclusion!(provider.to_s, DOMAIN_PROVIDERS, "provider")
+
+        app["domain_provider"] = { provider.to_s => build_domain_config(provider.to_s, opts) }
+        wrap_success
+      end
+
+      def remove_domain_provider
+        app["domain_provider"] = {}
+        wrap_success
+      end
+
+      # ─── Server ───
+
+      def server(name, master: false, type: nil, location: nil, count: 1)
+        validate_presence!(name, "name")
+        validate_positive!(count, "count") if count
+
+        servers[name.to_s] = {
+          "master" => master,
+          "type" => type,
+          "location" => location,
+          "count" => count
+        }.compact
+        wrap_success
+      end
+
+      def remove_server(name)
+        validate_presence!(name, "name")
+        validate_exists!(servers, name.to_s, "server")
+        check_server_references(name.to_s)
+
+        servers.delete(name.to_s)
+        wrap_success
+      end
+
+      # ─── Volume ───
+
+      def volume(server_name, name, size: 10)
+        validate_presence!(server_name, "server")
+        validate_presence!(name, "name")
+        validate_positive!(size, "size") if size
+        validate_exists!(servers, server_name.to_s, "server")
+
+        servers[server_name.to_s]["volumes"] ||= {}
+        servers[server_name.to_s]["volumes"][name.to_s] = { "size" => size }
+        wrap_success
+      end
+
+      def remove_volume(server_name, name)
+        validate_presence!(server_name, "server")
+        validate_presence!(name, "name")
+        validate_exists!(servers, server_name.to_s, "server")
+
+        volumes = servers[server_name.to_s]["volumes"] || {}
+        validate_exists!(volumes, name.to_s, "volume")
+
+        volumes.delete(name.to_s)
+        wrap_success
+      end
+
+      # ─── App ───
+
+      def app_entry(name, servers:, domain: nil, subdomain: nil, port: nil, command: nil, pre_run_command: nil, env: nil, mounts: nil)
+        validate_presence!(name, "name")
+        validate_servers_array!(servers)
+        validate_server_refs!(servers)
+
+        apps[name.to_s] = {
+          "servers" => servers.map(&:to_s),
+          "domain" => domain,
+          "subdomain" => subdomain,
+          "port" => port,
+          "command" => command,
+          "pre_run_command" => pre_run_command,
+          "env" => env,
+          "mounts" => mounts
+        }.compact
+        wrap_success
+      end
+
+      def remove_app(name)
+        validate_presence!(name, "name")
+        validate_exists!(apps, name.to_s, "app")
+
+        apps.delete(name.to_s)
+        wrap_success
+      end
+
+      # ─── Database ───
+
+      def database(servers:, adapter:, image: nil, url: nil, user: nil, password: nil, database_name: nil, mount: nil, path: nil)
+        validate_servers_array!(servers)
+        validate_presence!(adapter, "adapter")
+        validate_inclusion!(adapter.to_s.downcase, DATABASE_ADAPTERS, "adapter")
+        validate_server_refs!(servers)
+
+        secrets = build_database_secrets(adapter, user, password, database_name)
+
+        app["database"] = {
+          "servers" => servers.map(&:to_s),
+          "adapter" => adapter.to_s,
+          "image" => image,
+          "url" => url,
+          "secrets" => secrets.empty? ? nil : secrets,
+          "mount" => mount,
+          "path" => path
+        }.compact
+        wrap_success
+      end
+
+      def remove_database
+        app.delete("database")
+        wrap_success
+      end
+
+      # ─── Service ───
+
+      def service(name, servers:, image:, port: nil, command: nil, env: nil, mount: nil)
+        validate_presence!(name, "name")
+        validate_servers_array!(servers)
+        validate_presence!(image, "image")
+        validate_server_refs!(servers)
+
+        services[name.to_s] = {
+          "servers" => servers.map(&:to_s),
+          "image" => image.to_s,
+          "port" => port,
+          "command" => command,
+          "env" => env,
+          "mount" => mount
+        }.compact
+        wrap_success
+      end
+
+      def remove_service(name)
+        validate_presence!(name, "name")
+        validate_exists!(services, name.to_s, "service")
+
+        services.delete(name.to_s)
+        wrap_success
+      end
+
+      # ─── Secret ───
+
+      def secret(key, value)
+        validate_presence!(key, "key")
+        raise ArgumentError, "value is required" if value.nil?
+
+        secrets[key.to_s] = value.to_s
+        wrap_success
+      end
+
+      def remove_secret(key)
+        validate_presence!(key, "key")
+        validate_exists!(secrets, key.to_s, "secret")
+
+        secrets.delete(key.to_s)
+        wrap_success
+      end
+
+      # ─── Env ───
+
+      def env(key, value)
+        validate_presence!(key, "key")
+        raise ArgumentError, "value is required" if value.nil?
+
+        env_vars[key.to_s] = value.to_s
+        wrap_success
+      end
+
+      def remove_env(key)
+        validate_presence!(key, "key")
+        validate_exists!(env_vars, key.to_s, "env")
+
+        env_vars.delete(key.to_s)
+        wrap_success
+      end
+
+      # ─── Output ───
+
+      def to_h
+        @data
+      end
+
+      def to_yaml
+        YAML.dump(@data)
+      end
+
+      private
+
+        def app
+          @data["application"] ||= {}
+        end
+
+        def servers
+          app["servers"] ||= {}
+        end
+
+        def apps
+          app["app"] ||= {}
+        end
+
+        def services
+          app["services"] ||= {}
+        end
+
+        def secrets
+          app["secrets"] ||= {}
+        end
+
+        def env_vars
+          app["env"] ||= {}
+        end
+
+        # ─── Validation Helpers ───
+
+        def validate_presence!(value, field)
+          raise ArgumentError, "#{field} is required" if value.blank?
+        end
+
+        def validate_inclusion!(value, list, field)
+          raise ArgumentError, "#{field} must be one of: #{list.join(', ')}" unless list.include?(value)
+        end
+
+        def validate_positive!(value, field)
+          raise ArgumentError, "#{field} must be positive" if value && value < 1
+        end
+
+        def validate_exists!(hash, key, type)
+          raise Errors::ConfigValidationError, "#{type} '#{key}' not found" unless hash.key?(key)
+        end
+
+        def validate_servers_array!(server_refs)
+          raise ArgumentError, "servers is required" if server_refs.to_a.empty?
+          raise ArgumentError, "servers must be an array" unless server_refs.is_a?(Array)
+        end
+
+        def validate_server_refs!(server_refs)
+          defined = servers.keys
+          server_refs.each do |ref|
+            raise Errors::ConfigValidationError, "server '#{ref}' not found" unless defined.include?(ref.to_s)
+          end
+        end
+
+        def check_server_references(server_name)
+          apps.each do |app_name, cfg|
+            if (cfg["servers"] || []).include?(server_name)
+              raise Errors::ConfigValidationError, "app.#{app_name} references server '#{server_name}'"
+            end
+          end
+
+          db = app["database"]
+          if db && (db["servers"] || []).include?(server_name)
+            raise Errors::ConfigValidationError, "database references server '#{server_name}'"
+          end
+
+          services.each do |svc_name, cfg|
+            if (cfg["servers"] || []).include?(server_name)
+              raise Errors::ConfigValidationError, "services.#{svc_name} references server '#{server_name}'"
+            end
+          end
+        end
+
+        # ─── Config Builders ───
+
+        def build_compute_config(provider, opts)
+          case provider
+          when "hetzner"
+            {
+              "api_token" => opts[:api_token],
+              "server_type" => opts[:server_type],
+              "server_location" => opts[:server_location],
+              "architecture" => opts[:architecture]
+            }.compact
+          when "aws"
+            {
+              "access_key_id" => opts[:access_key_id],
+              "secret_access_key" => opts[:secret_access_key],
+              "region" => opts[:region],
+              "instance_type" => opts[:instance_type],
+              "architecture" => opts[:architecture]
+            }.compact
+          when "scaleway"
+            {
+              "secret_key" => opts[:secret_key],
+              "project_id" => opts[:project_id],
+              "zone" => opts[:zone],
+              "server_type" => opts[:server_type],
+              "architecture" => opts[:architecture]
+            }.compact
+          end
+        end
+
+        def build_domain_config(provider, opts)
+          case provider
+          when "cloudflare"
+            {
+              "api_token" => opts[:api_token],
+              "account_id" => opts[:account_id]
+            }.compact
+          end
+        end
+
+        def build_database_secrets(adapter, user, password, database_name)
+          case adapter.to_s.downcase
+          when "postgres", "postgresql"
+            {
+              "POSTGRES_USER" => user,
+              "POSTGRES_PASSWORD" => password,
+              "POSTGRES_DB" => database_name
+            }.compact
+          when "mysql"
+            {
+              "MYSQL_USER" => user,
+              "MYSQL_PASSWORD" => password,
+              "MYSQL_DATABASE" => database_name
+            }.compact
+          else
+            {}
+          end
+        end
+
+        def wrap_success
+          Result.success(@data)
+        end
+
+        def wrap_failure(type, message)
+          Result.failure(type, message)
+        end
+    end
+  end
+end

data/lib/nvoi/configuration/database.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module Configuration
+    # Database defines database configuration
+    class Database
+      attr_accessor :servers, :adapter, :url, :image, :mount, :secrets, :path
+
+      def initialize(data = nil)
+        data ||= {}
+        @servers = data["servers"] || []
+        @adapter = data["adapter"]
+        @url = data["url"]
+        @image = data["image"]
+        @mount = data["mount"] || {}
+        @secrets = data["secrets"] || {}
+        @path = data["path"]
+      end
+
+      def postgres?
+        @adapter&.downcase&.start_with?("postgres")
+      end
+
+      def mysql?
+        @adapter&.downcase == "mysql"
+      end
+
+      def sqlite?
+        @adapter&.downcase&.start_with?("sqlite")
+      end
+
+      def to_service_spec(namer)
+        return nil if @adapter&.downcase&.start_with?("sqlite")
+
+        port = case @adapter&.downcase
+        when "mysql" then 3306
+        else 5432
+        end
+
+        image = @image || Utils::Constants::DATABASE_IMAGES[@adapter&.downcase]
+
+        Configuration::Deployment.new(
+          name: namer.database_service_name,
+          image:,
+          port:,
+          env: nil,
+          mounts: @mount,
+          replicas: 1,
+          stateful_set: true,
+          secrets: @secrets,
+          servers: @servers
+        )
+      end
+    end
+  end
+end

data/lib/nvoi/configuration/deploy.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module Configuration
+    # Deploy represents the root deployment configuration
+    class Deploy
+      attr_accessor :application
+
+      def initialize(data = nil)
+        data ||= {}
+        @application = Application.new(data["application"])
+      end
+    end
+  end
+end

data/lib/nvoi/{objects/service_spec.rb → configuration/deployment.rb}

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 module Nvoi
-  module Objects
-    # ServiceSpec is the CORE primitive - pure K8s deployment specification
-    class ServiceSpec
+  module Configuration
+    # Deployment is the normalized service definition ready for deployment
+    # Created by Configuration::Database and Configuration::Service
+    class Deployment
       attr_accessor :name, :image, :port, :command, :env, :mounts, :replicas,
                     :healthcheck, :stateful_set, :secrets, :servers
 

data/lib/nvoi/{objects/config_override.rb → configuration/override.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Nvoi
-  module Objects
-    # ConfigOverride allows CLI to override app name and subdomain for branch deployments
-    class ConfigOverride
+  module Configuration
+    # Override allows CLI to override app name and subdomain for branch deployments
+    class Override
       BRANCH_PATTERN = /\A[a-z0-9-]+\z/
 
       attr_reader :branch
@@ -32,7 +32,7 @@ module Nvoi
       private
 
         def validate!(branch)
-          raise ArgumentError, "--branch value required" unless branch && !branch.empty?
+          raise ArgumentError, "--branch value required" if branch.blank?
           raise ArgumentError, "invalid branch format (lowercase alphanumeric and hyphens only)" unless branch.match?(BRANCH_PATTERN)
         end
 

data/lib/nvoi/configuration/providers.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module Configuration
+    module Providers
+      # DomainProvider contains domain provider configuration
+      class DomainProvider
+        attr_accessor :cloudflare
+
+        def initialize(data = nil)
+          data ||= {}
+          @cloudflare = data["cloudflare"] ? Cloudflare.new(data["cloudflare"]) : nil
+        end
+      end
+
+      # ComputeProvider contains compute provider configuration
+      class ComputeProvider
+        attr_accessor :hetzner, :aws, :scaleway
+
+        def initialize(data = nil)
+          data ||= {}
+          @hetzner = data["hetzner"] ? Hetzner.new(data["hetzner"]) : nil
+          @aws = data["aws"] ? AwsCfg.new(data["aws"]) : nil
+          @scaleway = data["scaleway"] ? Scaleway.new(data["scaleway"]) : nil
+        end
+      end
+
+      # Cloudflare contains Cloudflare-specific configuration
+      class Cloudflare
+        attr_accessor :api_token, :account_id
+
+        def initialize(data = nil)
+          data ||= {}
+          @api_token = data["api_token"]
+          @account_id = data["account_id"]
+        end
+      end
+
+      # Hetzner contains Hetzner-specific configuration
+      class Hetzner
+        attr_accessor :api_token, :server_type, :server_location, :architecture
+
+        def initialize(data = nil)
+          data ||= {}
+          @api_token = data["api_token"]
+          @server_type = data["server_type"]
+          @server_location = data["server_location"]
+          @architecture = data["architecture"]
+        end
+      end
+
+      # AwsCfg contains AWS-specific configuration
+      class AwsCfg
+        attr_accessor :access_key_id, :secret_access_key, :region, :instance_type, :architecture
+
+        def initialize(data = nil)
+          data ||= {}
+          @access_key_id = data["access_key_id"]
+          @secret_access_key = data["secret_access_key"]
+          @region = data["region"]
+          @instance_type = data["instance_type"]
+          @architecture = data["architecture"]
+        end
+      end
+
+      # Scaleway contains Scaleway-specific configuration
+      class Scaleway
+        attr_accessor :secret_key, :project_id, :zone, :server_type, :architecture
+
+        def initialize(data = nil)
+          data ||= {}
+          @secret_key = data["secret_key"]
+          @project_id = data["project_id"]
+          @zone = data["zone"] || "fr-par-1"
+          @server_type = data["server_type"]
+          @architecture = data["architecture"]
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/configuration/result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module Configuration
+    # Result wrapper for Builder operations
+    class Result
+      attr_reader :data, :error_type, :error_message
+
+      def initialize(data: nil, error_type: nil, error_message: nil)
+        @data = data
+        @error_type = error_type
+        @error_message = error_message
+      end
+
+      def success? = @error_type.nil?
+      def failure? = !success?
+
+      def self.success(data)
+        new(data:)
+      end
+
+      def self.failure(type, message)
+        new(error_type: type, error_message: message)
+      end
+
+      # Result for init operations (includes encryption artifacts)
+      class Init
+        attr_reader :config, :master_key, :ssh_public_key, :error_type, :error_message
+
+        def initialize(config: nil, master_key: nil, ssh_public_key: nil, error_type: nil, error_message: nil)
+          @config = config
+          @master_key = master_key
+          @ssh_public_key = ssh_public_key
+          @error_type = error_type
+          @error_message = error_message
+        end
+
+        def success? = @error_type.nil?
+        def failure? = !success?
+      end
+    end
+  end
+end