dato 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b90a79945cd778861e44a0d09bfffad27a606d4f51e448cf3a83c85ef98b5a
-  data.tar.gz: 9dfa1d22880392d377e0fd15d2f72302c7acbc242d58d954ebfe7fa4242e1a26
+  metadata.gz: 7107aad93e6809c4140c2167e1d5ce2cc446c45bf05e66521916a357a52f2b2a
+  data.tar.gz: a3f336225fa11c3d721b07171b432201326b03e58fb394ec0f26911c5320f8e9
 SHA512:
-  metadata.gz: 29413d8c200bcc4c648151409d6be67889edb172325fc78e8b9d81d4042eae7c6a880aef623c505a2c697ec727577d393b4cdff861f8f2369ce63ec1cf20485d
-  data.tar.gz: 46b2fb45112a58f7942deeda7143d2493976ae4957f2a6996b75b06c56cdb892a142355da83f09cbed705bacf249f9c7249f2ba652eb64b6199dccfed16bb7b8
+  metadata.gz: df93d0a0883dd2a6d728cb5f8ceb7e4b6c46f9063a75bc79ecf1442458f67f5a32aa0a95f7be9a9fc89360b02636206c1bf4bcc6f7689847eb2d2c7e9a269969
+  data.tar.gz: 4a733da2b3626f47018fc6fadefb96d50ffd4959b871f952c78c382225504faa6d894d4aaaed68ba458d91fa6e138fe18ec2e28d550d840a2771c6e823cf48a4

data/Rakefile

@@ -1,44 +1,6 @@
 # frozen_string_literal: true
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-require 'open-uri'
-
-require_relative './build/build_client'
 
 RSpec::Core::RakeTask.new(:spec)
-
 task default: :spec
-
-desc 'Regenerates the client starting from the JSON Hyperschema'
-task :regenerate do
-  BuildClient.new(
-    open('https://site-api.datocms.com/docs/site-api-hyperschema.json').read,
-    'site',
-    %w(session item upload user#update)
-  ).build
-
-  BuildClient.new(
-    open('https://site-api.datocms.com/docs/account-api-hyperschema.json').read,
-    'account',
-    %w(
-      session
-      account#create account#reset_password
-      subscription
-      portal_session
-    )
-  ).build
-end
-
-desc 'Open an irb (or pry) session preloaded with this gem'
-task :console do
-  begin
-    require 'pry'
-    gem_name = File.basename(Dir.pwd)
-    sh %(pry -I lib -r #{gem_name}.rb)
-  rescue LoadError => _
-    sh %(irb -rubygems -I lib -r #{gem_name}.rb)
-  end
-end
-
-require 'rubocop/rake_task'
-RuboCop::RakeTask.new

data/lib/dato/account/client.rb

@@ -1,79 +1,12 @@
 # frozen_string_literal: true
-require 'faraday'
-require 'faraday_middleware'
-require 'json'
-require 'active_support/core_ext/hash/indifferent_access'
-
-require 'dato/version'
-
-require 'dato/account/repo/account'
-require 'dato/account/repo/site'
-require 'dato/account/repo/deploy_event'
-require 'dato/api_error'
-
-require 'cacert'
+require 'dato/api_client'
 
 module Dato
   module Account
     class Client
-      REPOS = {
-        account: Repo::Account,
-        sites: Repo::Site,
-        deploy_events: Repo::DeployEvent
-      }.freeze
-
-      attr_reader :token, :base_url, :schema, :extra_headers
-
-      def initialize(token, options = {})
-        @token = token
-        @base_url = options[:base_url] || 'https://account-api.datocms.com'
-        @extra_headers = options[:extra_headers] || {}
-      end
-
-      REPOS.each do |method_name, repo_klass|
-        define_method method_name do
-          instance_variable_set(
-            "@#{method_name}",
-            instance_variable_get("@#{method_name}") ||
-            repo_klass.new(self)
-          )
-        end
-      end
-
-      def request(*args)
-        connection.send(*args).body.with_indifferent_access
-      rescue Faraday::SSLError => e
-        raise e if ENV['SSL_CERT_FILE'] == Cacert.pem
-
-        Cacert.set_in_env
-        request(*args)
-      rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
-        raise e
-      rescue Faraday::ClientError => e
-        raise ApiError, e
-      end
-
-      private
-
-      def connection
-        options = {
-          url: base_url,
-          headers: extra_headers.merge(
-            'Accept' => 'application/json',
-            'Content-Type' => 'application/json',
-            'Authorization' => "Bearer #{@token}",
-            'User-Agent' => "ruby-client v#{Dato::VERSION}"
-          )
-        }
+      include ApiClient
 
-        @connection ||= Faraday.new(options) do |c|
-          c.request :json
-          c.response :json, content_type: /\bjson$/
-          c.response :raise_error
-          c.use FaradayMiddleware::FollowRedirects
-          c.adapter :net_http
-        end
-      end
+      json_schema 'account-api'
     end
   end
 end

data/lib/dato/api_client.rb

@@ -0,0 +1,98 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'json_schema'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/inflector'
+
+require 'dato/version'
+require 'dato/repo'
+
+require 'dato/api_error'
+
+require 'cacert'
+
+module Dato
+  module ApiClient
+    def self.included(base)
+      base.extend ClassMethods
+
+      base.class_eval do
+        attr_reader :token, :base_url, :schema, :extra_headers
+      end
+    end
+
+    module ClassMethods
+      def json_schema(subdomain)
+        define_method(:initialize) do |token, options = {}|
+          @token = token
+          @base_url = options[:base_url] || "https://#{subdomain}.datocms.com"
+          @extra_headers = options[:extra_headers] || {}
+        end
+
+        url = URI.parse("https://#{subdomain}.datocms.com/docs/#{subdomain}-hyperschema.json")
+        response = Net::HTTP.get(url)
+
+        schema = JsonSchema.parse!(JSON.parse(response))
+        schema.expand_references!
+
+        schema.definitions.each do |type, schema|
+          is_collection = schema.links.select{|x| x.rel === "instances"}.any?
+
+          if is_collection
+            type = type.pluralize
+          end
+
+          define_method(type) do
+            instance_variable_set(
+              "@#{type}",
+              instance_variable_get("@#{type}") ||
+              Dato::Repo.new(self, type, schema)
+            )
+          end
+        end
+      end
+    end
+
+    def request(*args)
+      connection.send(*args).body.with_indifferent_access
+    rescue Faraday::SSLError => e
+      raise e if ENV['SSL_CERT_FILE'] == Cacert.pem
+
+      Cacert.set_in_env
+      request(*args)
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+      puts e.message
+      raise e
+    rescue Faraday::ClientError => e
+      error = ApiError.new(e)
+      puts '===='
+      puts error.message
+      puts '===='
+      raise error
+    end
+
+    private
+
+    def connection
+      options = {
+        url: base_url,
+        headers: extra_headers.merge(
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@token}",
+          'User-Agent' => "ruby-client v#{Dato::VERSION}",
+          'X-Api-Version' => "2"
+        )
+      }
+
+      @connection ||= Faraday.new(options) do |c|
+        c.request :json
+        c.response :json, content_type: /\bjson$/
+        c.response :raise_error
+        c.use FaradayMiddleware::FollowRedirects
+        c.adapter :net_http
+      end
+    end
+  end
+end

data/lib/dato/json_api_serializer.rb

@@ -1,21 +1,11 @@
 # frozen_string_literal: true
 module Dato
   class JsonApiSerializer
-    attr_reader :type, :attributes, :relationships
-    attr_reader :required_attributes, :required_relationships
-
-    def initialize(
-      type:,
-      attributes: [],
-      required_attributes: [],
-      relationships: {},
-      required_relationships: []
-    )
+    attr_reader :link, :type
+
+    def initialize(type, link)
+      @link = link
       @type = type
-      @attributes = attributes
-      @required_attributes = required_attributes
-      @relationships = relationships
-      @required_relationships = required_relationships
     end
 
     def serialize(resource, id = nil)
@@ -37,7 +27,7 @@ module Dato
     def serialized_attributes(resource)
       result = {}
 
-      attributes.each do |attribute|
+      attributes(resource).each do |attribute|
         if resource.key? attribute
           result[attribute] = resource[attribute]
         elsif required_attributes.include? attribute
@@ -54,7 +44,6 @@ module Dato
       relationships.each do |relationship, meta|
         if resource.key? relationship
           value = resource[relationship]
-
           data = if value
                    if meta[:collection]
                      value.map do |id|
@@ -66,12 +55,78 @@ module Dato
                  end
           result[relationship] = { data: data }
 
-        elsif required_relationships.include? relationship
+        elsif required_relationships.include?(relationship)
           throw "Required attribute: #{relationship}"
         end
       end
 
       result
     end
+
+    def attributes(resource)
+      if type == "item"
+        resource.keys - [:item_type, :id]
+      end
+
+      link_attributes["properties"].keys.map(&:to_sym)
+    end
+
+    def required_attributes
+      if type == "item"
+        []
+      end
+
+      (link_attributes.required || []).map(&:to_sym)
+    end
+
+    def relationships
+      if type == "item"
+        {
+          item_type: { collection: false, type: 'item_type' }
+        }
+      end
+
+      if !link_relationships
+        return {}
+      end
+
+      link_relationships.properties.reduce({}) do |acc, (relationship, schema)|
+        is_collection = schema.properties["data"].type.first == 'array'
+
+        definition = if is_collection
+                       schema.properties['data'].items
+                     elsif schema.properties['data'].type.first == 'object'
+                       schema.properties['data']
+                     else
+                       schema.properties['data'].any_of.find do |option|
+                         option.type.first == 'object'
+                       end
+                     end
+
+        type = definition.properties['type']
+                         .pattern.source.gsub(/(^\^|\$$)/, '')
+
+        acc[relationship.to_sym] = {
+          collection: is_collection,
+          type: type,
+        }
+      end
+    end
+
+    def required_relationships
+      if type == "item"
+        %i(item_type)
+      end
+
+      (link_relationships.required || []).map(&:to_sym)
+    end
+
+    def link_attributes
+      link.schema.properties["data"].properties["attributes"]
+    end
+
+    def link_relationships
+      link.schema.properties["data"].properties["relationships"]
+    end
   end
 end

data/lib/dato/paginator.rb

@@ -0,0 +1,33 @@
+module Dato
+  class Paginator
+    def initialize(client, base_endpoint, filters)
+      @client, @base_endpoint, @filters = client, base_endpoint, filters
+    end
+
+    def response
+      items_per_page = 100
+
+      base_response = @client.request(
+        :get, @base_endpoint, @filters.dup.merge('page[limit]' => items_per_page)
+      )
+
+      extra_pages = (
+        base_response[:meta][:total_count] / items_per_page.to_f
+      ).ceil - 1
+
+      extra_pages.times do |page|
+        base_response[:data] += @client.request(
+          :get,
+          @base_endpoint,
+          @filters.dup.merge(
+            'page[offset]' => items_per_page * (page + 1),
+            'page[limit]' => items_per_page
+          )
+        )[:data]
+      end
+
+      base_response
+    end
+  end
+end
+

data/lib/dato/repo.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+require 'dato/json_api_serializer'
+require 'dato/json_api_deserializer'
+require 'dato/paginator'
+
+module Dato
+  class Repo
+    attr_reader :client, :type, :schema
+
+    IDENTITY_REGEXP = /\{\(.*?definitions%2F(.*?)%2Fdefinitions%2Fidentity\)}/
+
+    METHOD_NAMES = {
+      "instances" => :all,
+      "self" => :find,
+    }
+
+    def initialize(client, type, schema)
+      @client = client
+      @type = type
+      @schema = schema
+
+      schema.links.each do |link|
+        method_name = METHOD_NAMES.fetch(link.rel, link.rel)
+
+        self.define_singleton_method(method_name) do |*args|
+          min_arguments_count = [
+            link.href.scan(IDENTITY_REGEXP).size,
+            link.schema && link.method != :get ? 1 : 0
+          ].sum
+
+          args.size >= min_arguments_count or
+            raise ArgumentError.new(
+              "wrong number of arguments (given #{args.size}, expected #{min_arguments_count})"
+          )
+
+          last_url_id = nil
+
+          url = link["href"].gsub(IDENTITY_REGEXP) do |_stuff|
+            last_url_id = args.shift.to_s
+          end
+
+          response = if %i(post put).include?(link.method)
+            body = if link.schema
+              unserialized_body = args.shift
+
+              JsonApiSerializer.new(type, link).serialize(
+                unserialized_body,
+                last_url_id
+              )
+            else
+              {}
+            end
+
+            client.request(link.method, url, body)
+
+          elsif link.method == :delete
+            client.request(:delete, url)
+
+          elsif link.method == :get
+            query_string = args.shift
+
+            all_pages = (args[0] || {}).
+              symbolize_keys.
+              fetch(:all_pages, false)
+
+            is_paginated_endpoint = link.schema &&
+              link.schema.properties.has_key?("page[limit]")
+
+            if is_paginated_endpoint && all_pages
+              Paginator.new(client, url, query_string).response
+            else
+              client.request(:get, url, query_string)
+            end
+          end
+
+          options = if args.any?
+                      args.shift.symbolize_keys
+                    else
+                      {}
+                    end
+
+          if options.fetch(:deserialize_response, true)
+            JsonApiDeserializer.new.deserialize(response)
+          else
+            response
+          end
+        end
+      end
+    end
+  end
+end