dnsmadeeasy 0.3.5 → 1.0.1

data/lib/dnsmadeeasy/zone/plan_renderer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DnsMadeEasy
+  module Zone
+    # Renders zone plans for humans and automation.
+    class PlanRenderer
+      def initialize(plan)
+        @plan = plan
+      end
+
+      def to_text
+        return "No changes.\n" if plan.empty?
+
+        [
+          section('Create', plan.creates),
+          section('Update', plan.updates),
+          section('Skipped Creates', plan.skipped_creates),
+          section('Skipped Deletes', plan.skipped_deletes),
+          section('Manual Review', plan.ambiguous)
+        ].reject(&:empty?).join("\n")
+      end
+
+      def to_json(*)
+        JSON.pretty_generate(plan_hash)
+      end
+
+      private
+
+      attr_reader :plan
+
+      def section(title, actions)
+        return '' if actions.empty?
+
+        ([title] + actions.sort_by(&:sort_key).map { |action| "  - #{action_line(action)}" }).join("\n")
+      end
+
+      def action_line(action)
+        case action.action
+        when 'create'
+          record_line(action.record)
+        when 'update'
+          "#{record_line(action.remote_record)} -> #{record_line(action.desired_record)}"
+        when 'skipped_create', 'skipped_delete'
+          "#{record_line(action.record)} (#{action.message})"
+        when 'ambiguous'
+          "#{record_line(action.remote_record)} -> #{record_line(action.desired_record)} (#{action.message})"
+        end
+      end
+
+      def record_line(record)
+        [record.owner, record.type, record.priority, record.value, "(ttl=#{record.ttl})"].compact.join(' ')
+      end
+
+      def plan_hash
+        {
+          creates: plan.creates.map { |action| action_hash(action) },
+          updates: plan.updates.map { |action| action_hash(action) },
+          skipped_creates: plan.skipped_creates.map { |action| action_hash(action) },
+          skipped_deletes: plan.skipped_deletes.map { |action| action_hash(action) },
+          ambiguous: plan.ambiguous.map { |action| action_hash(action) }
+        }
+      end
+
+      def action_hash(action)
+        {
+          action: action.action,
+          record: record_hash(action.record),
+          remote_record: record_hash(action.remote_record),
+          desired_record: record_hash(action.desired_record),
+          message: action.message
+        }.compact
+      end
+
+      def record_hash(record)
+        return unless record
+
+        {
+          owner: record.owner,
+          type: record.type,
+          value: record.value,
+          ttl: record.ttl,
+          priority: record.priority,
+          weight: record.weight,
+          port: record.port
+        }.compact
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/provider_record.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/record'
+
+module DnsMadeEasy
+  module Zone
+    # Associates provider metadata with a provider-neutral DNS record.
+    class ProviderRecord < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :record, Record
+      attribute :provider_id, Types::Coercible::Integer.optional.default(nil)
+      attribute :source_id, Types::OptionalString.default(nil)
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/record.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+
+module DnsMadeEasy
+  module Zone
+    # Provider-neutral DNS record value object.
+    class Record < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :owner, Types::NonEmptyString
+      attribute :type, Types::RecordType
+      attribute :value, Types::NonEmptyString
+      attribute :ttl, Types::Ttl.default(300)
+      attribute :priority, Types::OptionalInteger.default(nil)
+      attribute :weight, Types::OptionalInteger.default(nil)
+      attribute :port, Types::OptionalInteger.default(nil)
+
+      def sort_key
+        [
+          normalized_owner,
+          type_order,
+          type,
+          priority || -1,
+          weight || -1,
+          port || -1,
+          value,
+          ttl
+        ]
+      end
+
+      private
+
+      def normalized_owner
+        owner == '@' ? '' : owner
+      end
+
+      def type_order
+        Types::DNS_RECORD_TYPES.index(type) || Types::DNS_RECORD_TYPES.length
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/record_set.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/zone/record'
+
+module DnsMadeEasy
+  module Zone
+    # Deterministically ordered collection of zone records.
+    class RecordSet < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :records, Types::Array.of(Record).default([].freeze)
+
+      def sorted
+        records.sort_by(&:sort_key)
+      end
+
+      def include?(record)
+        records.include?(record)
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/remote_adapter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+require 'dnsmadeeasy/zone/provider_record'
+require 'dnsmadeeasy/zone/record'
+require 'dnsmadeeasy/zone/remote_records'
+
+module DnsMadeEasy
+  module Zone
+    # Converts DNS Made Easy API record hashes into provider-neutral zone records.
+    class RemoteAdapter
+      include Dry::Monads[:result]
+
+      SUPPORTED_RECORD_TYPES = Types::DNS_RECORD_TYPES.freeze
+      SOURCE_ID = 'dns-made-easy'
+
+      def initialize(response, domain:, default_ttl: 300)
+        @response = response
+        @domain = domain
+        @default_ttl = default_ttl
+      end
+
+      def call
+        provider_records = []
+        warnings = []
+
+        remote_records.each do |remote_record|
+          if remote_record['type'] == 'HTTPRED'
+            warnings << omitted_httpred_warning(remote_record)
+          elsif SUPPORTED_RECORD_TYPES.include?(remote_record['type'])
+            provider_records << provider_record(remote_record)
+          else
+            return Failure(["Unsupported DNS Made Easy record type: #{remote_record['type']}"])
+          end
+        end
+
+        Success(RemoteRecords.new(provider_records: provider_records, warnings: warnings))
+      rescue Dry::Struct::Error => e
+        Failure([e.message])
+      end
+
+      private
+
+      attr_reader :response,
+                  :domain,
+                  :default_ttl
+
+      def remote_records
+        response.fetch('data', [])
+      end
+
+      def provider_record(remote_record)
+        ProviderRecord.new(
+          record: zone_record(remote_record),
+          provider_id: remote_record['id'],
+          source_id: SOURCE_ID
+        )
+      end
+
+      def zone_record(remote_record)
+        Record.new(
+          owner: owner(remote_record),
+          type: remote_record['type'],
+          value: record_value(remote_record),
+          ttl: remote_record['ttl'] || default_ttl,
+          priority: remote_record['mxLevel'] || remote_record['priority'],
+          weight: remote_record['weight'],
+          port: remote_record['port']
+        )
+      end
+
+      # DME returns TXT/SPF values with the zone-file quotes embedded, while
+      # Record holds unquoted text (Parser strips, Serializer re-quotes).
+      def record_value(remote_record)
+        value = remote_record['value']
+        return value unless %w[TXT SPF].include?(remote_record['type'])
+
+        value.delete_prefix('"').delete_suffix('"')
+      end
+
+      def owner(remote_record)
+        name = remote_record['name'].to_s
+        return '@' if name.empty? || name == domain || name == domain.delete_suffix('.')
+
+        name.delete_suffix(".#{domain.delete_suffix('.')}")
+      end
+
+      def omitted_httpred_warning(remote_record)
+        record_name = remote_record['name'].to_s.empty? ? '@' : remote_record['name']
+        "Omitted HTTPRED record #{record_name} -> #{remote_record['value']}"
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/remote_records.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'dry/struct'
+require 'dnsmadeeasy/types'
+require 'dnsmadeeasy/zone/provider_record'
+require 'dnsmadeeasy/zone/record_set'
+
+module DnsMadeEasy
+  module Zone
+    # Provider records plus non-fatal warnings from remote conversion.
+    class RemoteRecords < Dry::Struct
+      transform_keys(&:to_sym)
+
+      attribute :provider_records, Types::Array.of(ProviderRecord).default([].freeze)
+      attribute :warnings, Types::Array.of(Types::StrictString).default([].freeze)
+
+      def records
+        provider_records.map(&:record)
+      end
+
+      def record_set
+        RecordSet.new(records: records)
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy/zone/serializer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'dnsmadeeasy/zone/file'
+
+module DnsMadeEasy
+  module Zone
+    # Emits deterministic, normalized zone-file text.
+    class Serializer
+      def initialize(zone_file, omit_apex_ns: true)
+        @zone_file = zone_file
+        @omit_apex_ns = omit_apex_ns
+      end
+
+      def to_s
+        lines = [
+          "$ORIGIN #{zone_file.origin}",
+          "$TTL #{zone_file.ttl}",
+          ''
+        ]
+        lines.concat(serialized_records)
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      attr_reader :zone_file,
+                  :omit_apex_ns
+
+      def serialized_records
+        grouped_records.flat_map.with_index do |records, index|
+          lines = records.map { |record| serialize_record(record) }
+          index.zero? ? lines : [''] + lines
+        end
+      end
+
+      def grouped_records
+        serializable_records.chunk { |record| record_group(record) }.map(&:last)
+      end
+
+      def serializable_records
+        zone_file.records
+                 .reject { |record| omit_apex_ns && record.owner == '@' && record.type == 'NS' }
+                 .sort_by { |record| serializer_sort_key(record) }
+      end
+
+      def record_group(record)
+        case record.type
+        when 'MX'
+          :mail
+        when 'TXT', 'SPF'
+          :text
+        else
+          :address
+        end
+      end
+
+      def serializer_sort_key(record)
+        [
+          serializer_type_group(record),
+          normalized_owner(record.owner),
+          record.type,
+          record.priority || -1,
+          record.value,
+          record.ttl
+        ]
+      end
+
+      def serializer_type_group(record)
+        case record.type
+        when 'A', 'AAAA', 'CNAME', 'ANAME', 'NS', 'PTR'
+          0
+        when 'MX', 'SRV'
+          1
+        when 'TXT', 'SPF'
+          2
+        else
+          3
+        end
+      end
+
+      def normalized_owner(owner)
+        owner == '@' ? '' : owner
+      end
+
+      def serialize_record(record)
+        [record.owner.ljust(8), ttl_token(record), 'IN', record.type.ljust(7), record_payload(record)].compact.join(' ')
+      end
+
+      # A single $TTL cannot represent a real zone, so records that deviate
+      # from the zone default carry an explicit TTL.
+      def ttl_token(record)
+        record.ttl == zone_file.ttl ? nil : record.ttl.to_s
+      end
+
+      def record_payload(record)
+        case record.type
+        when 'MX'
+          "#{record.priority} #{record.value}"
+        when 'SRV'
+          "#{record.priority} #{record.weight} #{record.port} #{record.value}"
+        when 'TXT', 'SPF'
+          quote_text(record.value)
+        else
+          record.value
+        end
+      end
+
+      def quote_text(value)
+        return value if value.start_with?('"') && value.end_with?('"')
+
+        %("#{value}")
+      end
+    end
+  end
+end

data/lib/dnsmadeeasy.rb

@@ -6,25 +6,49 @@ module DnsMadeEasy
 end
 
 require 'dnsmadeeasy/version'
+require 'dnsmadeeasy/types'
 require 'dnsmadeeasy/credentials'
 require 'dnsmadeeasy/api/client'
+require 'dnsmadeeasy/cli/launcher'
+require 'dnsmadeeasy/zone/record'
+require 'dnsmadeeasy/zone/provider_record'
+require 'dnsmadeeasy/zone/record_set'
+require 'dnsmadeeasy/zone/file'
+require 'dnsmadeeasy/zone/parser'
+require 'dnsmadeeasy/zone/aname_flattener'
+require 'dnsmadeeasy/zone/apply_executor'
+require 'dnsmadeeasy/zone/apply_result'
+require 'dnsmadeeasy/zone/diff'
+require 'dnsmadeeasy/zone/plan'
+require 'dnsmadeeasy/zone/plan_action'
+require 'dnsmadeeasy/zone/plan_renderer'
+require 'dnsmadeeasy/zone/remote_adapter'
+require 'dnsmadeeasy/zone/remote_records'
+require 'dnsmadeeasy/zone/serializer'
 
 module DnsMadeEasy
-  class Error < StandardError;
+  class Error < StandardError
   end
-  class AuthenticationError < Error;
+
+  class AuthenticationError < Error
   end
-  class APIKeyAndSecretMissingError < Error;
+
+  class APIKeyAndSecretMissingError < Error
   end
-  class InvalidCredentialKeys < Error;
+
+  class InvalidCredentialKeys < Error
   end
-  class AbstractMethodError < Error;
+
+  class AbstractMethodError < Error
   end
-  class InvalidCredentialsFormatError < Error;
+
+  class InvalidCredentialsFormatError < Error
   end
-  class NoSuchAccountError < Error;
+
+  class NoSuchAccountError < Error
   end
-  class NoDomainError < Error;
+
+  class NoDomainError < Error
   end
 
   class << self
@@ -38,26 +62,22 @@ module DnsMadeEasy
     def configure_from_file(file = nil,
                             account = nil,
                             encryption_key = nil)
-
       credentials = ::DnsMadeEasy::Credentials.keys_from_file(
-        file: file || ::DnsMadeEasy::Credentials.default_credentials_path(user: ENV['USER']),
+        file: file || ::DnsMadeEasy::Credentials.default_credentials_path(user: ENV.fetch('USER', nil)),
         account: account,
         encryption_key: encryption_key
       )
-      if credentials
-        configure do |config|
-          config.api_key    = credentials.api_key
-          config.api_secret = credentials.api_secret
-        end
-      else
-        raise APIKeyAndSecretMissingError, "Unable to load valid api keys from #{file}!"
+      raise APIKeyAndSecretMissingError, "Unable to load valid api keys from #{file}!" unless credentials
+
+      configure do |config|
+        config.api_key    = credentials.api_key
+        config.api_secret = credentials.api_secret
       end
     end
 
     def credentials_from_file(file: DnsMadeEasy::Credentials.default_credentials_path,
                               account: nil,
                               encryption_key: nil)
-
       DnsMadeEasy::Credentials.keys_from_file file: file,
                                               account: account,
                                               encryption_key: encryption_key
@@ -67,41 +87,51 @@ module DnsMadeEasy
       self.default_api_key = value
     end
 
+    def api_key
+      default_api_key
+    end
+
     def api_secret=(value)
       self.default_api_secret = value
     end
 
-    def client(**options)
-      @client ||= create_client(false, **options)
+    def api_secret
+      default_api_secret
     end
 
-    def sandbox_client(**options)
-      @sandbox_client ||= create_client(true, **options)
+    def client(**)
+      @client ||= create_client(false, **)
+    end
+
+    def sandbox_client(**)
+      @sandbox_client ||= create_client(true, **)
     end
 
     def create_client(sandbox = false,
                       api_key: default_api_key,
                       api_secret: default_api_secret,
 
-                      **options)
+                      **)
       raise APIKeyAndSecretMissingError, 'Please set #api_key and #api_secret' unless api_key && api_secret
 
-      ::DnsMadeEasy::Api::Client.new(api_key, api_secret, sandbox, **options)
+      ::DnsMadeEasy::Api::Client.new(api_key, api_secret, sandbox, **)
     end
 
     # Basically delegate it all to the Client instance
     # if the method call is supported.
     #
-    # rubocop:todo Style/MissingRespondToMissing
-    # rubocop:todo Style/MethodMissingSuper
-    def method_missing(method, *args, &block)
+    def method_missing(method, ...)
       if client.respond_to?(method)
-        client.send(method, *args, &block)
+        client.send(method, ...)
       else
-        super(method, *args, &block)
+        super
       end
     end
-    # rubocop:enable Style/MethodMissingSuper
-    # rubocop:enable Style/MissingRespondToMissing
+
+    def respond_to_missing?(method, include_private = false)
+      client.respond_to?(method, include_private) || super
+    rescue APIKeyAndSecretMissingError
+      super
+    end
   end
 end