gandi_v5 0.3.0 → 0.8.0

data/lib/gandi_v5/email/forward.rb

@@ -76,18 +76,12 @@ class GandiV5
       #   e.g. ("alice" "*lice", "alic*").
       # @return [Array<GandiV5::Email::Forward>]
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def self.list(fqdn, page: (1..), **params)
-        page = [page.to_i] unless page.respond_to?(:each)
-
+      def self.list(fqdn, page: (1..), per_page: 100, **params)
         params.reject! { |_k, v| v.nil? }
 
         mailboxes = []
-        page.each do |page_number|
-          _response, data = GandiV5.get url(fqdn), params: params.merge(page: page_number)
-          break if data.empty?
-
+        GandiV5.paginated_get(url(fqdn), page, per_page, params: params) do |data|
           mailboxes += data.map { |mailbox| from_gandi mailbox.merge(fqdn: fqdn) }
-          break if data.count < params.fetch(:per_page, 100)
         end
         mailboxes
       end

data/lib/gandi_v5/email/mailbox.rb

@@ -105,6 +105,39 @@ class GandiV5
         data['message']
       end
 
+      # Upgrade a standard mailbox to premium.
+      # If the current slot is a free one, a new premium slot is created and
+      # used for the mailbox. Otherwise, the slot is upgraded to premium.
+      # @see https://api.gandi.net/docs/email#patch-v5-email-mailboxes-domain-mailbox_id-type
+      # @param sharing_id [String, #to_s, nil] (optional)
+      #   the organisation ID to bill for the mailbox.
+      # @param dry_run [Boolean] whether the details should be checked instead
+      #                          of actually upgrading the mailbox.
+      # @return [true] if the mailbox was upgraded
+      # @return [false] if the mailbox was not upgraded (it's already premium)
+      # @return [Hash] if doing a dry run, you get what Gandi returns
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error
+      def upgrade(sharing_id: nil, dry_run: false)
+        patch_type :premium, sharing_id, dry_run
+      end
+
+      # Downgrade a premium mailbox to standard.
+      # If a free slot is available, the premium slot is destroyed
+      # (and refunded) and the free one is used for the mailbox.
+      # Otherwise, the slot is downgraded to standard.
+      # @see https://api.gandi.net/docs/email#patch-v5-email-mailboxes-domain-mailbox_id-type
+      # @param sharing_id [String, #to_s, nil] (optional)
+      #   the organisation ID to bill for the mailbox.
+      # @param dry_run [Boolean] whether the details should be checked instead
+      #                          of actually downgrading the mailbox.
+      # @return [true] if the mailbox was downgraded
+      # @return [false] if the mailbox was not downgraded (it's already standard)
+      # @return [Hash] if doing a dry run, you get what Gandi returns
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error
+      def downgrade(sharing_id: nil, dry_run: false)
+        patch_type :standard, sharing_id, dry_run
+      end
+
       # Create a new mailbox.
       # Note that before you can create a mailbox, you must have a slot available.
       # @see https://api.gandi.net/docs/email#post-v5-email-mailboxes-domain
@@ -113,10 +146,13 @@ class GandiV5
       # @param password [String, #to_s] the password to use.
       # @param aliases [Array<String, #to_s>] any alternative email address to be used.
       # @param type [:standard, :premium] the type of mailbox slot to use.
+      # @param dry_run [Boolean] whether the details should be checked instead
+      #                          of actually creating the mailbox.
       # @return [GandiV5::Email::Mailbox] The created mailbox.
       # @raise [GandiV5::Error] if no slots are available.
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def self.create(fqdn, login, password, aliases: [], type: :standard)
+      # rubocop:disable Metrics/AbcSize
+      def self.create(fqdn, login, password, aliases: [], type: :standard, dry_run: false)
         fail ArgumentError, "#{type.inspect} is not a valid type" unless TYPES.include?(type)
         if GandiV5::Email::Slot.list.none? { |slot| slot.mailbox_type == type && slot.inactive? }
           fail GandiV5::Error, "no available #{type} slots"
@@ -131,9 +167,11 @@ class GandiV5
           aliases: aliases.push
         }.to_json
 
-        response, _data = GandiV5.post url(fqdn), body
-        fetch fqdn, response.headers[:location].split('/').last
+        response, data = GandiV5.post(url(fqdn), body, 'Dry-Run': dry_run ? 1 : 0)
+
+        dry_run ? data : fetch(fqdn, response.headers[:location].split('/').last)
       end
+      # rubocop:enable Metrics/AbcSize
 
       # Get information for a mailbox.
       # @see https://api.gandi.net/docs/email#get-v5-email-mailboxes-domain-mailbox_id
@@ -159,19 +197,13 @@ class GandiV5
       #   e.g. ("alice" "*lice", "alic*").
       # @return [Array<GandiV5::Email::Mailbox>]
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def self.list(fqdn, page: (1..), **params)
-        page = [page.to_i] unless page.respond_to?(:each)
-
+      def self.list(fqdn, page: (1..), per_page: 100, **params)
         params['~login'] = params.delete(:login)
         params.reject! { |_k, v| v.nil? }
 
         mailboxes = []
-        page.each do |page_number|
-          _response, data = GandiV5.get url(fqdn), params: params.merge(page: page_number)
-          break if data.empty?
-
+        GandiV5.paginated_get(url(fqdn), page, per_page, params: params) do |data|
           mailboxes += data.map { |mailbox| from_gandi mailbox }
-          break if data.count < params.fetch(:per_page, 100)
         end
         mailboxes
       end
@@ -240,6 +272,20 @@ class GandiV5
       def crypt_password(password)
         self.class.send :crypt_password, password
       end
+
+      def patch_type(new_type, sharing_id, dry_run)
+        fail ArgumentError unless TYPES.include?(new_type)
+        return false if type == new_type
+
+        url_ = "#{url}/type"
+        url_ = sharing_id ? "#{url_}?sharing_id=#{sharing_id}" : url_
+        body = { mailbox_type: new_type }
+
+        _response, data = GandiV5.patch(url_, body.to_json, 'Dry-Run': dry_run ? 1 : 0)
+
+        @type = new_type unless dry_run
+        dry_run ? data : true
+      end
     end
   end
 end

data/lib/gandi_v5/email/slot.rb

@@ -78,15 +78,23 @@ class GandiV5
       # but require more mailboxes on that domain, you must first purchase additional slots.
       # @see https://api.gandi.net/docs/email#post-v5-email-slots-domain
       # @param fqdn [String, #to_s] the fully qualified domain name to add the slot to.
-      # @param type [:standard, :premium] Tyhe type of slot to add.
+      # @param type [:standard, :premium] The type of slot to add.
+      # @param sharing_id [nil, String, #to_s] either:
+      #   * nil (default) - nothing special happens
+      #   * an organization ID - pay using another organization
+      #     (you need to have billing permissions on the organization
+      #     and use the same organization name for the domain name's owner).
+      #     The invoice will be edited using this organization's information.
       # @return [String] The confirmation message from Gandi.
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def self.create(fqdn, type = :standard)
+      def self.create(fqdn, type: :standard, sharing_id: nil)
         body = {
           mailbox_type: type
         }.to_json
 
-        response, _data = GandiV5.post url(fqdn), body
+        url_ = url(fqdn)
+        url_ += "?sharing_id=#{sharing_id}" if sharing_id
+        response, _data = GandiV5.post url_, body
         fetch fqdn, response.headers[:location].split('/').last
       end
 

data/lib/gandi_v5/live_dns.rb

@@ -4,8 +4,6 @@
 class GandiV5
   # Gandi LiveDNS Management API.
   class LiveDNS
-    BASE = 'https://dns.api.gandi.net/api/v5/'
-
     RECORD_TYPES = %w[
       A AAAA CNAME MX NS TXT ALIAS
       WKS SRV LOC SPF CAA DS SSHFP PTR KEY DNAME TLSA OPENPGPKEY CDS
@@ -21,16 +19,6 @@ class GandiV5
       GandiV5::LiveDNS::Domain.list
     end
 
-    # @see GandiV5::LiveDNS::Zone.fetch
-    def self.zone(uuid)
-      GandiV5::LiveDNS::Zone.fetch(uuid)
-    end
-
-    # @see GandiV5::LiveDNS::Zone.list
-    def self.zones
-      GandiV5::LiveDNS::Zone.list
-    end
-
     # Raise an error if passed type is invalid.
     # @param type [String] the record type to check.
     # @return [nil]

data/lib/gandi_v5/live_dns/domain.rb

@@ -5,19 +5,12 @@ class GandiV5
     # A domain name within the LiveDNS system.
     # @!attribute [r] fqdn
     #   @return [String]
-    # @!attribute [r] zone_uuid
-    #   @return [String]
+    # @!attribute [r] automatic_snapshots
+    #   @return [Boolean]
     class Domain
       include GandiV5::Data
-      include GandiV5::LiveDNS::HasZoneRecords
-
-      members :fqdn
 
-      member(
-        :zone_uuid,
-        gandi_key: 'zone',
-        converter: GandiV5::Data::Converter.new(from_gandi: ->(zone) { zone&.split('/')&.last })
-      )
+      members :fqdn, :automatic_snapshots
 
       # Refetch the information for this domain from Gandi.
       # @return [GandiV5::LiveDNS::Domain]
@@ -27,35 +20,283 @@ class GandiV5
         from_gandi data
       end
 
-      # Change the zone used by this domain.
-      # @param uuid [String, #uuid, #to_s] the UUID of the zone this domain should now use.
+      # Update this domain's settings.
+      # @param automatic_snapshots [String, #to_s]
+      #   Enable or disable the automatic creation of new snapshots when records are changed.
       # @return [String] The confirmation message from Gandi.
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def change_zone(uuid)
-        uuid = uuid.uuid if uuid.respond_to?(:uuid)
-        _response, data = GandiV5.patch url, { zone_uuid: uuid }.to_json
-        self.zone_uuid = uuid
+      def update(automatic_snapshots:)
+        _response, data = GandiV5.patch url, { automatic_snapshots: automatic_snapshots }.to_json
+        self.automatic_snapshots = automatic_snapshots
         data['message']
       end
 
-      # @see GandiV5::LiveDNS::Zone.fetch
-      def fetch_zone
-        GandiV5::LiveDNS::Zone.fetch zone_uuid
+      # @overload fetch_records()
+      #   Fetch all records for this domain.
+      #   @param page [Integer, #each<Integer>] which page(s) of results to get.
+      #     If page is not provided keep querying until an empty list is returned.
+      #     If page responds to .each then iterate until an empty list is returned.
+      #   @param per_page [Integer, #to_s] (optional default 100) how many results ot get per page.
+      # @overload fetch_records(name)
+      #   Fetch records for a name.
+      #   @param name [String] the name to fetch records for.
+      #   @param page [Integer, #each<Integer>] which page(s) of results to get.
+      #     If page is not provided keep querying until an empty list is returned.
+      #     If page responds to .each then iterate until an empty list is returned.
+      #   @param per_page [Integer, #to_s] (optional default 100) how many results ot get per page.
+      # @overload fetch_records(name, type)
+      #   Fetch records of a type for a name.
+      #   @param name [String] the name to fetch records for.
+      #   @param type [String] the record type to fetch.
+      #   @param page [Integer, #each<Integer>] which page(s) of results to get.
+      #     If page is not provided keep querying until an empty list is returned.
+      #     If page responds to .each then iterate until an empty list is returned.
+      #   @param per_page [Integer, #to_s] (optional default 100) how many results ot get per page.
+      # @return [Array<GandiV5::LiveDNS::Domain::Record>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def fetch_records(name = nil, type = nil, page: (1..), per_page: 100)
+        GandiV5::LiveDNS.require_valid_record_type type if type
+
+        url_ = "#{url}/records"
+        url_ += "/#{CGI.escape name}" if name
+        url_ += "/#{CGI.escape type}" if type
+
+        all = []
+        GandiV5.paginated_get(url_, page, per_page) do |data|
+          all += [*data].map { |item| GandiV5::LiveDNS::Domain::Record.from_gandi item }
+        end
+        all
       end
 
-      # The domain's zone (fetching from Gandi if required).
-      # @return [GandiV5::LiveDNS::Zone]
+      # @overload fetch_zone_lines()
+      #   Fetch all records for this domain.
+      # @overload fetch_zone_lines(name)
+      #   Fetch records for a name.
+      #   @param name [String] the name to fetch records for.
+      # @overload fetch_zone_lines(name, type)
+      #   Fetch records of a type for a name.
+      #   @param name [String] the name to fetch records for.
+      #   @param type [String] the record type to fetch.
+      # @return [String]
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def zone
-        @zone ||= fetch_zone
+      def fetch_zone_lines(name = nil, type = nil)
+        GandiV5::LiveDNS.require_valid_record_type type if type
+
+        url_ = "#{url}/records"
+        url_ += "/#{CGI.escape name}" if name
+        url_ += "/#{CGI.escape type}" if type
+
+        GandiV5.get(url_, accept: 'text/plain').last
+      end
+
+      # Add record to this domain.
+      # @param name [String]
+      # @param type [String]
+      # @param ttl [Integer]
+      # @param values [Array<String>]
+      # @return [String] The confirmation message from Gandi.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def add_record(name, type, ttl, *values)
+        GandiV5::LiveDNS.require_valid_record_type type
+        fail ArgumentError, 'ttl must be positive and non-zero' unless ttl.positive?
+        fail ArgumentError, 'there must be at least one value' if values.none?
+
+        body = {
+          rrset_name: name,
+          rrset_type: type,
+          rrset_ttl: ttl,
+          rrset_values: values
+        }.to_json
+        _response, data = GandiV5.post "#{url}/records", body
+        data['message']
+      end
+
+      # @overload delete_records()
+      #   Delete all records for this domain.
+      # @overload delete_records(name)
+      #   Delete records for a name.
+      #   @param name [String] the name to delete records for.
+      # @overload delete_records(name, type)
+      #   Delete records of a type for a name.
+      #   @param name [String] the name to delete records for.
+      #   @param type [String] the record type to delete.
+      # @return [nil]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def delete_records(name = nil, type = nil)
+        GandiV5::LiveDNS.require_valid_record_type(type) if type
+
+        url_ = "#{url}/records"
+        url_ += "/#{CGI.escape name}" if name
+        url_ += "/#{CGI.escape type}" if type
+        GandiV5.delete(url_).last
+      end
+
+      # Replace records for the domain.
+      #   @param name [String, nil] only replaces records for this name.
+      #   @param type [String, nil] only replaces record of this type (requires name).
+      #   @param values [Array<String>] the values to set for the record.
+      #   @raise [ArgumentError] if ttl is present and type is absent.
+      # @return [String] The confirmation message from Gandi.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def replace_records(records, name: nil, type: nil)
+        if type
+          GandiV5::LiveDNS.require_valid_record_type(type) if type
+          fail ArgumentError, 'missing keyword: name' if name.nil?
+        end
+
+        url_ = "#{url}/records"
+        url_ += "/#{CGI.escape name}" if name
+        url_ += "/#{CGI.escape type}" if type
+
+        body = if type && name
+                 { rrset_values: records }
+               else
+                 { items: records.map { |r| r.transform_keys { |k| "rrset_#{k}" } } }
+               end
+
+        _response, data = GandiV5.put url_, body.to_json
+        data['message']
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      # Replace all records for this domain.
+      # @param text [String] zone file lines to replace the records with.
+      # @return [String] The confirmation message from Gandi.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def replace_zone_lines(text)
+        _response, data = GandiV5.put "#{url}/records", text, 'content-type': 'text/plain'
+        data['message']
+      end
+
+      # The list of nameservers that this domain is using according to LiveDNS' systems.
+      #  * Either there are no NS records on @ and the 3 hashed nameservers are returned
+      #    (ns-{123}-{abc}.gandi.net)
+      #  * Or some NS records exist on @ and it will return those
+      # @see https://api.gandi.net/docs/domains#get-v5-domain-domains-domain-name$
+      # @return [Array<String>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def name_servers
+        @name_servers ||= fetch_name_servers
+      end
+
+      # Requery Gandi for the domain's name servers.
+      # @see https://api.gandi.net/docs/domains#get-v5-domain-domains-domain-name$
+      # @return [Array<String>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def fetch_name_servers
+        _response, data = GandiV5.get "#{url}/nameservers"
+        @name_servers = data
+      end
+
+      # The list of DNSSEC keys for the domain.
+      # If you need the fingerprint, public_key or tag attributes you'll need
+      # use GandiV5::LiveDNS::Domain::DnssecKey.fetch on each item.
+      # @return [Array<GandiV5::LiveDNS::Domain::DnssecKey>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def dnssec_keys
+        @dnssec_keys ||= fetch_dnssec_keys
+      end
+
+      # Requery Gandi for the domain's DNSSEC keys.
+      # @return [Array<GandiV5::LiveDNS::Domain::DnssecKey>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def fetch_dnssec_keys
+        @dnssec_keys = GandiV5::LiveDNS::Domain::DnssecKey.list(fqdn)
+      end
+
+      # The list of TSIG keys for the domain.
+      # If you need the secret, fingerprint, public_key or tag attributes you'll need
+      # to use GandiV5::LiveDNS::Domain::DnssecKey.fetch on each item.
+      # @return [Array<GandiV5::LiveDNS::Domain::TsigKey>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def tsig_keys
+        @tsig_keys ||= fetch_tsig_keys
+      end
+
+      # Requery Gandi for the domain's TSIG keys.
+      # @return [Array<GandiV5::LiveDNS::Domain::TsigKey>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def fetch_tsig_keys
+        _response, data = GandiV5.get "#{url}/axfr/tsig"
+        data.map { |item| GandiV5::LiveDNS::Domain::TsigKey.from_gandi item }
+      end
+
+      # Add a Tsig key to this domain.
+      # @param key [GandiV5::LiveDNS::Domain::TsigKey, #uuid, String, #to_s]
+      #   the key to add.
+      # @param sharing_id [nil, String, #to_s]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def add_tsig_key(key, sharing_id: nil)
+        key = key.uuid if key.respond_to?(:uuid)
+        url_ = "#{url}/axfr/tsig/#{key}"
+        url_ += "?sharing_id=#{CGI.escape sharing_id}" if sharing_id
+        _response, _data = GandiV5.put url_
+      end
+
+      # Remove a Tsig key from this domain.
+      # @param key [GandiV5::LiveDNS::Domain::TsigKey, #uuid, String, #to_s]
+      #   the key to remove.
+      # @param sharing_id [nil, String, #to_s]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def remove_tsig_key(key, sharing_id: nil)
+        key = key.uuid if key.respond_to?(:uuid)
+        url_ = "#{url}/axfr/tsig/#{key}"
+        url_ += "?sharing_id=#{CGI.escape sharing_id}" if sharing_id
+        _response, _data = GandiV5.delete url_
+      end
+
+      # The list of AXFR clients for the domain.
+      # @return [Array<String>] list of IP addresses.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def axfr_clients
+        @axfr_clients ||= fetch_axfr_clients
+      end
+
+      # Requery Gandi for the domain's AXFR clients.
+      # @return [Array<String>] list of IP addresses.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def fetch_axfr_clients
+        _response, data = GandiV5.get "#{url}/axfr/slaves"
+        data
+      end
+
+      # Add an AXFR client to this domain.
+      # @param ip [String, #to_s] the IP address to add.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def add_axfr_client(ip)
+        _response, _data = GandiV5.put "#{url}/axfr/slaves/#{ip}"
+      end
+
+      # Remove and AXFR client from this domain.
+      # @param ip [String, #to_s] the IP address to remove.
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def remove_axfr_client(ip)
+        _response, _data = GandiV5.delete "#{url}/axfr/slaves/#{ip}"
       end
 
       # List the domains.
-      # @return [Array<GandiV5::LiveDNS::Domain>]
+      # @param page [#each<Integer, #to_s>] the page(s) of results to retrieve.
+      #   If page is not provided keep querying until an empty list is returned.
+      #   If page responds to .each then iterate until an empty list is returned.
+      # @param per_page [Integer, #to_s] (optional default 100) how many results to get per page.
+      # @param sharing_id [String, #to_s] (optional) filter by domains assigned to a given user.
+      # @return [Array<String>]
       # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
-      def self.list
-        _response, data = GandiV5.get url
-        data.map { |item| from_gandi item }
+      def self.list(page: (1..), per_page: 100, sharing_id: nil)
+        page = [page.to_i] unless page.respond_to?(:each)
+        params = { per_page: per_page }
+        params[:sharing_id] = sharing_id unless sharing_id.nil?
+
+        domains = []
+        page.each do |page_number|
+          _resp, data = GandiV5.get url, params: params.merge(page: page_number)
+          break if data.empty?
+
+          domains += data.map { |item| item['fqdn'] }
+          break if data.count < per_page
+        end
+        domains
       end
 
       # Get a domain.
@@ -67,14 +308,57 @@ class GandiV5
         from_gandi data
       end
 
+      # Create a new domain in the LiveDNS system.
+      # You must have sufficent permission to manage the domain to do this.
+      # @param fqdn [String, #to_s] the fully qualified domain to add to LiveDNS.
+      # @param records [Array<Hash, GandiV5::LiveDNS::Domain::Record, #to_h, nil>]
+      # @param ttl [Integer, #to_s, nil] the TTL of the SOA record.
+      #   Note that this is not a default TTL that will be used for the records in the zone.
+      #   the records (if any) to add to the created zone.
+      # @param sharing_id [nil, String, #to_s]
+      # @return [GandiV5::LiveDNS::Domain]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def self.create(fqdn, records = nil, soa_ttl: nil, sharing_id: nil)
+        body = { fqdn: fqdn, zone: {} }
+        body[:zone][:ttl] = soa_ttl if soa_ttl
+        if records
+          body[:zone][:items] = records.map do |r|
+            r.to_h.transform_keys { |k| "rrset_#{k}" }
+          end
+        end
+
+        url_ = url
+        url_ += "?sharing_id=#{CGI.escape sharing_id}" if sharing_id
+
+        GandiV5.post url_, body.to_json
+        fetch(fqdn)
+      end
+
+      # Fetch the list of known record types (A, CNAME, etc.)
+      # @return [Array<String>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def self.record_types
+        GandiV5.get("#{BASE}livedns/dns/rrtypes").last
+      end
+
+      # Get the LiveDNS servers to use for a domain.
+      # Does not take into account any NS records that exist in the zone.
+      # @param fqdn [String, #to_s] the fully qualified domain to hash in
+      #   in order to get the LiveDNS servers to use.
+      # @return [Array<String>]
+      # @raise [GandiV5::Error::GandiError] if Gandi returns an error.
+      def self.generic_name_servers(fqdn)
+        GandiV5.get("#{BASE}livedns/nameservers/#{CGI.escape fqdn}").last
+      end
+
       private
 
       def url
-        "#{BASE}domains/#{CGI.escape(fqdn)}"
+        "#{BASE}livedns/domains/#{CGI.escape fqdn}"
       end
 
       def self.url(fqdn = nil)
-        "#{BASE}domains" + (fqdn ? "/#{CGI.escape(fqdn)}" : '')
+        "#{BASE}livedns/domains" + (fqdn ? "/#{CGI.escape fqdn}" : '')
       end
       private_class_method :url
     end