nvoi 0.1.5 → 0.1.7

data/lib/nvoi/config_api/actions/compute_provider.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetComputeProvider < Base
+        PROVIDERS = %w[hetzner aws scaleway].freeze
+
+        protected
+
+          def mutate(data, provider:, **opts)
+            raise ArgumentError, "provider is required" if provider.nil? || provider.to_s.empty?
+            raise ArgumentError, "provider must be one of: #{PROVIDERS.join(', ')}" unless PROVIDERS.include?(provider.to_s)
+
+            app(data)["compute_provider"] = { provider.to_s => build_config(provider.to_s, opts) }
+          end
+
+        private
+
+          def build_config(provider, opts)
+            case provider
+            when "hetzner"
+              {
+                "api_token" => opts[:api_token],
+                "server_type" => opts[:server_type],
+                "server_location" => opts[:server_location]
+              }.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]
+              }.compact
+            when "scaleway"
+              {
+                "secret_key" => opts[:secret_key],
+                "project_id" => opts[:project_id],
+                "zone" => opts[:zone],
+                "server_type" => opts[:server_type]
+              }.compact
+            end
+          end
+      end
+
+      class DeleteComputeProvider < Base
+        protected
+
+          def mutate(data, **)
+            app(data)["compute_provider"] = {}
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/database.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetDatabase < Base
+        ADAPTERS = %w[postgres postgresql mysql sqlite sqlite3].freeze
+
+        protected
+
+          def mutate(data, servers:, adapter:, image: nil, url: nil, user: nil, password: nil, database: nil, mount: nil, path: nil)
+            raise ArgumentError, "servers is required" if servers.nil? || servers.empty?
+            raise ArgumentError, "servers must be an array" unless servers.is_a?(Array)
+            raise ArgumentError, "adapter is required" if adapter.nil? || adapter.to_s.empty?
+            raise ArgumentError, "adapter must be one of: #{ADAPTERS.join(', ')}" unless ADAPTERS.include?(adapter.to_s.downcase)
+
+            validate_server_refs(data, servers)
+
+            secrets = build_secrets(adapter, user, password, database)
+
+            app(data)["database"] = {
+              "servers" => servers.map(&:to_s),
+              "adapter" => adapter.to_s,
+              "image" => image,
+              "url" => url,
+              "secrets" => secrets.empty? ? nil : secrets,
+              "mount" => mount,
+              "path" => path
+            }.compact
+          end
+
+        private
+
+          def validate_server_refs(data, servers)
+            defined = (app(data)["servers"] || {}).keys
+            servers.each do |ref|
+              raise Errors::ConfigValidationError, "server '#{ref}' not found" unless defined.include?(ref.to_s)
+            end
+          end
+
+          def build_secrets(adapter, user, password, database)
+            case adapter.to_s.downcase
+            when "postgres", "postgresql"
+              {
+                "POSTGRES_USER" => user,
+                "POSTGRES_PASSWORD" => password,
+                "POSTGRES_DB" => database
+              }.compact
+            when "mysql"
+              {
+                "MYSQL_USER" => user,
+                "MYSQL_PASSWORD" => password,
+                "MYSQL_DATABASE" => database
+              }.compact
+            else
+              {}
+            end
+          end
+      end
+
+      class DeleteDatabase < Base
+        protected
+
+          def mutate(data, **)
+            app(data).delete("database")
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/domain_provider.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetDomainProvider < Base
+        PROVIDERS = %w[cloudflare].freeze
+
+        protected
+
+          def mutate(data, provider:, **opts)
+            raise ArgumentError, "provider is required" if provider.nil? || provider.to_s.empty?
+            raise ArgumentError, "provider must be one of: #{PROVIDERS.join(', ')}" unless PROVIDERS.include?(provider.to_s)
+
+            app(data)["domain_provider"] = { provider.to_s => build_config(provider.to_s, opts) }
+          end
+
+        private
+
+          def build_config(provider, opts)
+            case provider
+            when "cloudflare"
+              {
+                "api_token" => opts[:api_token],
+                "account_id" => opts[:account_id]
+              }.compact
+            end
+          end
+      end
+
+      class DeleteDomainProvider < Base
+        protected
+
+          def mutate(data, **)
+            app(data)["domain_provider"] = {}
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/env.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetEnv < Base
+        protected
+
+          def mutate(data, key:, value:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+            raise ArgumentError, "value is required" if value.nil?
+
+            app(data)["env"] ||= {}
+            app(data)["env"][key.to_s] = value.to_s
+          end
+      end
+
+      class DeleteEnv < Base
+        protected
+
+          def mutate(data, key:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+
+            env = app(data)["env"] || {}
+            raise Errors::ConfigValidationError, "env '#{key}' not found" unless env.key?(key.to_s)
+
+            env.delete(key.to_s)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/init.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class Init
+        def call(name:, environment: "production")
+          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+          # Generate master key
+          master_key = Utils::Crypto.generate_key
+
+          # Generate SSH keypair (reuse existing utility)
+          private_key, public_key = Utils::ConfigLoader.generate_keypair
+
+          # Build initial config
+          config_data = {
+            "application" => {
+              "name" => name.to_s,
+              "environment" => environment.to_s,
+              "domain_provider" => {},
+              "compute_provider" => {},
+              "servers" => {},
+              "app" => {},
+              "services" => {},
+              "env" => {},
+              "secrets" => {},
+              "ssh_keys" => {
+                "private_key" => private_key,
+                "public_key" => public_key
+              }
+            }
+          }
+
+          # Encrypt config
+          yaml = YAML.dump(config_data)
+          encrypted_config = Utils::Crypto.encrypt(yaml, master_key)
+
+          InitResult.new(
+            config: encrypted_config,
+            master_key:,
+            ssh_public_key: public_key
+          )
+        rescue ArgumentError => e
+          InitResult.new(error_type: :invalid_args, error_message: e.message)
+        rescue Errors::ConfigError => e
+          InitResult.new(error_type: :config_error, error_message: e.message)
+        end
+      end
+
+      class InitResult
+        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

data/lib/nvoi/config_api/actions/secret.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetSecret < Base
+        protected
+
+          def mutate(data, key:, value:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+            raise ArgumentError, "value is required" if value.nil?
+
+            app(data)["secrets"] ||= {}
+            app(data)["secrets"][key.to_s] = value.to_s
+          end
+      end
+
+      class DeleteSecret < Base
+        protected
+
+          def mutate(data, key:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+
+            secrets = app(data)["secrets"] || {}
+            raise Errors::ConfigValidationError, "secret '#{key}' not found" unless secrets.key?(key.to_s)
+
+            secrets.delete(key.to_s)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/server.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetServer < Base
+        protected
+
+          def mutate(data, name:, master: false, type: nil, location: nil, count: 1)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "count must be positive" if count && count < 1
+
+            app(data)["servers"] ||= {}
+            app(data)["servers"][name.to_s] = {
+              "master" => master,
+              "type" => type,
+              "location" => location,
+              "count" => count
+            }.compact
+          end
+      end
+
+      class DeleteServer < Base
+        protected
+
+          def mutate(data, name:)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+            servers = app(data)["servers"] || {}
+            raise Errors::ConfigValidationError, "server '#{name}' not found" unless servers.key?(name.to_s)
+
+            servers.delete(name.to_s)
+          end
+
+          def validate(data)
+            check_orphaned_references(data)
+          end
+
+        private
+
+          def check_orphaned_references(data)
+            servers = (app(data)["servers"] || {}).keys
+
+            (app(data)["app"] || {}).each do |svc_name, svc|
+              (svc["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "app.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
+            end
+
+            db = app(data)["database"]
+            if db
+              (db["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "database references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
+            end
+
+            (app(data)["services"] || {}).each do |svc_name, svc|
+              (svc["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "services.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetService < Base
+        protected
+
+          def mutate(data, name:, servers:, image:, port: nil, command: nil, env: nil, mount: nil)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "servers is required" if servers.nil? || servers.empty?
+            raise ArgumentError, "servers must be an array" unless servers.is_a?(Array)
+            raise ArgumentError, "image is required" if image.nil? || image.to_s.empty?
+
+            validate_server_refs(data, servers)
+
+            app(data)["services"] ||= {}
+            app(data)["services"][name.to_s] = {
+              "servers" => servers.map(&:to_s),
+              "image" => image.to_s,
+              "port" => port,
+              "command" => command,
+              "env" => env,
+              "mount" => mount
+            }.compact
+          end
+
+        private
+
+          def validate_server_refs(data, servers)
+            defined = (app(data)["servers"] || {}).keys
+            servers.each do |ref|
+              raise Errors::ConfigValidationError, "server '#{ref}' not found" unless defined.include?(ref.to_s)
+            end
+          end
+      end
+
+      class DeleteService < Base
+        protected
+
+          def mutate(data, name:)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+            services = app(data)["services"] || {}
+            raise Errors::ConfigValidationError, "service '#{name}' not found" unless services.key?(name.to_s)
+
+            services.delete(name.to_s)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/volume.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetVolume < Base
+        protected
+
+          def mutate(data, server:, name:, size: 10)
+            raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "size must be positive" if size && size < 1
+
+            servers = app(data)["servers"] ||= {}
+            raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
+
+            servers[server.to_s]["volumes"] ||= {}
+            servers[server.to_s]["volumes"][name.to_s] = { "size" => size }
+          end
+      end
+
+      class DeleteVolume < Base
+        protected
+
+          def mutate(data, server:, name:)
+            raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+            servers = app(data)["servers"] || {}
+            raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
+
+            volumes = servers[server.to_s]["volumes"] || {}
+            raise Errors::ConfigValidationError, "volume '#{name}' not found on server '#{server}'" unless volumes.key?(name.to_s)
+
+            volumes.delete(name.to_s)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    # Base class for config transformations.
+    # Accepts a Hash, returns a Hash. No crypto - caller handles that.
+    class Base
+      def initialize(data)
+        @data = data
+      end
+
+      def call(**args)
+        mutate(@data, **args)
+        validate(@data)
+        Result.success(@data)
+      rescue Errors::ConfigValidationError => e
+        Result.failure(:validation_error, e.message)
+      rescue ArgumentError => e
+        Result.failure(:invalid_args, e.message)
+      end
+
+      protected
+
+        def mutate(_data, **_args)
+          raise NotImplementedError
+        end
+
+        def validate(_data)
+          # Subclasses can override to add validation
+          # Default: no validation (lightweight actions like set_env don't need full config validation)
+        end
+
+        def app(data)
+          data["application"] ||= {}
+        end
+    end
+  end
+end

data/lib/nvoi/config_api/result.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    class Result
+      attr_reader :data, :error_type, :error_message
+
+      def self.success(data)
+        new(data:)
+      end
+
+      def self.failure(type, message)
+        new(error_type: type, error_message: message)
+      end
+
+      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?
+    end
+  end
+end

data/lib/nvoi/config_api.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    class << self
+      # Init (creates new config - special case, handles crypto)
+      def init(**args)
+        Actions::Init.new.call(**args)
+      end
+
+      # Domain Provider
+      def set_domain_provider(data, **args)
+        Actions::SetDomainProvider.new(data).call(**args)
+      end
+
+      def delete_domain_provider(data)
+        Actions::DeleteDomainProvider.new(data).call
+      end
+
+      # Compute Provider
+      def set_compute_provider(data, **args)
+        Actions::SetComputeProvider.new(data).call(**args)
+      end
+
+      def delete_compute_provider(data)
+        Actions::DeleteComputeProvider.new(data).call
+      end
+
+      # Server
+      def set_server(data, **args)
+        Actions::SetServer.new(data).call(**args)
+      end
+
+      def delete_server(data, **args)
+        Actions::DeleteServer.new(data).call(**args)
+      end
+
+      # Volume
+      def set_volume(data, **args)
+        Actions::SetVolume.new(data).call(**args)
+      end
+
+      def delete_volume(data, **args)
+        Actions::DeleteVolume.new(data).call(**args)
+      end
+
+      # App
+      def set_app(data, **args)
+        Actions::SetApp.new(data).call(**args)
+      end
+
+      def delete_app(data, **args)
+        Actions::DeleteApp.new(data).call(**args)
+      end
+
+      # Database
+      def set_database(data, **args)
+        Actions::SetDatabase.new(data).call(**args)
+      end
+
+      def delete_database(data)
+        Actions::DeleteDatabase.new(data).call
+      end
+
+      # Secret
+      def set_secret(data, **args)
+        Actions::SetSecret.new(data).call(**args)
+      end
+
+      def delete_secret(data, **args)
+        Actions::DeleteSecret.new(data).call(**args)
+      end
+
+      # Env
+      def set_env(data, **args)
+        Actions::SetEnv.new(data).call(**args)
+      end
+
+      def delete_env(data, **args)
+        Actions::DeleteEnv.new(data).call(**args)
+      end
+
+      # Service
+      def set_service(data, **args)
+        Actions::SetService.new(data).call(**args)
+      end
+
+      def delete_service(data, **args)
+        Actions::DeleteService.new(data).call(**args)
+      end
+    end
+  end
+end