sanity-ruby 0.1.0

data/lib/sanity/http/patch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Http
+    class Patch
+      include Sanity::Http::Mutation
+    end
+  end
+end

data/lib/sanity/http/query.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+using Sanity::Refinements::Strings
+
+module Sanity
+  module Http
+    module Query
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+          base.extend(Forwardable)
+          base.delegate(%i[project_id api_version dataset token] => :"Sanity.config")
+        end
+      end
+
+      module ClassMethods
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      attr_reader :resource_klass, :result_wrapper
+
+      # @todo Add query support
+      def initialize(**args)
+        @resource_klass = args.delete(:resource_klass)
+        @result_wrapper = args.delete(:result_wrapper) || Sanity::Http::Results
+      end
+
+      # @todo Add query support
+      def call
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        http.use_ssl = uri.scheme == "https"
+
+        request = Module.const_get("Net::HTTP::#{method.to_s.classify}").new(uri, headers)
+
+        request.body = request_body
+
+        http.request(request).then do |result|
+          data = JSON.parse(result.body)
+
+          block_given? ? yield(result_wrapper.call(data)) : result_wrapper.call(data)
+        end
+      end
+
+      private
+
+      def request_body
+      end
+
+      def method
+        :get
+      end
+
+      def base_url
+        "https://#{project_id}.api.sanity.io/#{api_version}/#{api_endpoint}/#{dataset}"
+      end
+
+      def headers
+        {
+          "Content-Type": "application/json",
+          Authorization: "Bearer #{token}"
+        }
+      end
+
+      def uri
+        URI(base_url)
+      end
+    end
+  end
+end

data/lib/sanity/http/results.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Http
+    class Results
+      class << self
+        def call(result)
+          new(result).call
+        end
+      end
+
+      attr_reader :raw_result
+
+      def initialize(result)
+        @raw_result = result
+      end
+
+      # TODO: parse the JSON and return what the user asked for
+      # whether that just be the response, the document ids, or the
+      # the document object(s) the user mutated
+      def call
+        raw_result
+      end
+    end
+  end
+end

data/lib/sanity/http/where.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Hash#except! was added in Ruby 3
+using Sanity::Refinements::Hashes if RUBY_VERSION.to_i < 3.0
+
+module Sanity
+  module Http
+    class Where
+      include Sanity::Http::Query
+      delegate where_api_endpoint: :resource_klass
+      alias_method :api_endpoint, :where_api_endpoint
+
+      attr_reader :groq, :use_post, :groq_attributes, :variables
+
+      def initialize(**args)
+        super
+        @groq = args.delete(:groq) || ""
+        @variables = args.delete(:variables) || {}
+        @use_post = args.delete(:use_post) || false
+
+        @groq_attributes = args.except(:groq, :use_post, :resource_klass, :result_wrapper)
+      end
+
+      private
+
+      def method
+        use_post ? :post : :get
+      end
+
+      def uri
+        super.tap do |obj|
+          obj.query = URI.encode_www_form(query_and_variables) unless use_post
+        end
+      end
+
+      def query_and_variables
+        if use_post
+          {params: variables}
+        else
+          {}.tap do |hash|
+            variables.each do |key, value|
+              hash["$#{key}"] = "\"#{value}\""
+            end
+          end
+        end.merge(query: groq_query)
+      end
+
+      def groq_query
+        groq.empty? ? Sanity::Groqify.call(**groq_attributes) : groq
+      end
+
+      def request_body
+        return unless use_post
+
+        query_and_variables.to_json
+      end
+    end
+  end
+end

data/lib/sanity/mutatable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sanity
+  # Mutatable is responsible for setting the appropriate class methods
+  # that invoke Sanity::Http's mutatable classes
+  #
+  # The mutatable marco can limit what queries are accessible to the
+  # mutatable object
+  #
+  # @example provides default class methods
+  #   mutatable
+  #
+  # @example only add the `.create` method
+  #   mutatable only: %i(create)
+  #
+  # @example only add the `.create_or_replace`& `#create_or_replace` methods
+  #   mutatable only: %i(create_or_replace)
+  #
+  using Sanity::Refinements::Strings
+
+  module Mutatable
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      DEFAULT_KLASS_MUTATIONS = %i[create create_or_replace create_if_not_exists patch delete].freeze
+      DEFAULT_INSTANCE_MUTATIONS = %i[create create_or_replace create_if_not_exists delete].freeze
+      ALL_MUTATIONS = DEFAULT_KLASS_MUTATIONS | DEFAULT_INSTANCE_MUTATIONS
+
+      private
+
+      def mutatable(**options)
+        options.fetch(:only, ALL_MUTATIONS).each do |mutation|
+          if DEFAULT_KLASS_MUTATIONS.include? mutation.to_sym
+            define_singleton_method(mutation) do |**args|
+              Module.const_get("Sanity::Http::#{mutation.to_s.classify}").call(**args.merge(resource_klass: self))
+            end
+          end
+
+          if DEFAULT_INSTANCE_MUTATIONS.include? mutation.to_sym
+            define_method(mutation) do |**args|
+              Module.const_get("Sanity::Http::#{mutation.to_s.classify}").call(
+                **args.merge(params: attributes, resource_klass: self.class)
+              )
+            end
+          end
+        end
+
+        define_singleton_method("mutatable_api_endpoint") { options.fetch(:api_endpoint, "") }
+      end
+    end
+  end
+end

data/lib/sanity/queryable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sanity
+  # Queryable is responsible for setting the appropriate class methods
+  # that invoke Sanity::Http's query classes
+  #
+  # The queryable marco can limit what queries are accessible to the
+  # queryable object
+  #
+  # @example provides default class methods
+  #   queryable
+  #
+  # @example only add the `.where` method
+  #   queryable only: %i(where)
+  #
+  # @example only add the `.find` method
+  #   queryable only: %i(find)
+  #
+  using Sanity::Refinements::Strings
+
+  module Queryable
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      DEFAULT_KLASS_QUERIES = %i[find where].freeze
+
+      # See https://www.sanity.io/docs/http-query & https://www.sanity.io/docs/http-doc
+      QUERY_ENDPOINTS = {
+        find: "data/doc",
+        where: "data/query"
+      }.freeze
+
+      private
+
+      # @private
+      def queryable(**options)
+        options.fetch(:only, DEFAULT_KLASS_QUERIES).each do |query|
+          define_singleton_method(query) do |**args|
+            Module.const_get("Sanity::Http::#{query.to_s.classify}").call(**args.merge(resource_klass: self))
+          end
+          define_singleton_method("#{query}_api_endpoint") { QUERY_ENDPOINTS[query] }
+        end
+      end
+    end
+  end
+end

data/lib/sanity/refinements.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "sanity/refinements/strings"
+require "sanity/refinements/arrays"
+require "sanity/refinements/hashes"

data/lib/sanity/refinements/arrays.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Refinements
+    # Array refinements based on ActiveSupport methods.
+    #
+    # Using refinements as to:
+    #   1) not pollute the global namespace
+    #   2) not conflict with ActiveSupport in a Rails based project
+    #
+    # These methods are defined in the way as needed in this gem. They
+    # are not meant to replace the more robust ActiveSupport methods.
+    #
+    # Defining these here, removes the need for adding ActiveSupport
+    # as a dependency
+    module Arrays
+      refine Array.singleton_class do
+        def wrap(object)
+          if object.nil?
+            []
+          elsif object.respond_to?(:to_ary)
+            object.to_ary || [object]
+          else
+            [object]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sanity/refinements/hashes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Refinements
+    module Hashes
+      refine Hash do
+        # Defined in Ruby >= 3
+        def except!(*keys)
+          keys.each { |key| delete(key) }
+          self
+        end
+
+        # Defined in Ruby >= 3
+        def except(*keys)
+          dup.except!(*keys)
+        end
+      end
+    end
+  end
+end

data/lib/sanity/refinements/strings.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Refinements
+    # String refinements based on ActiveSupport methods.
+    #
+    # Using refinements as to:
+    #   1) not pollute the global namespace
+    #   2) not conflict with ActiveSupport in a Rails based project
+    #
+    # These methods are defined in the way as needed in this gem. They
+    # are not meant to replace the more robust ActiveSupport methods.
+    #
+    # Defining these here, removes the need for adding ActiveSupport
+    # as a dependency
+    module Strings
+      refine String do
+        def camelize_lower
+          split("_")[0..].each_with_index.map do |val, idx|
+            idx != 0 ? val.capitalize : val
+          end.join
+        end
+
+        def classify
+          split("_").map(&:capitalize).join
+        end
+
+        def demodulize
+          split("::")[-1]
+        end
+
+        def underscore
+          split(/(?=[A-Z])/).map(&:downcase).join("_")
+        end
+      end
+    end
+  end
+end

data/lib/sanity/resource.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Sanity
+  # Sanity::Resource is the base class used by
+  # the sanity resources defined within this gem.
+  #
+  # Out of the box it includes the following mixins:
+  #   Sanity::Attributable
+  #   Sanity::Mutatable
+  #   Sanity::Queryable
+  #
+  # Sanity::Document and Sanity::Asset both inherit
+  # from Sanity::Resource
+  #
+  # Any PORO in your project could become a
+  # Sanity::Resource via inheritance
+  #
+  # @example inherit from Sanity::Resource
+  #   class User < Sanity::Resource
+  #     attribute :first_name, default: ""
+  #     queryable
+  #     mutatable
+  #   end
+  #
+  class Resource
+    include Sanity::Attributable
+    include Sanity::Mutatable
+    include Sanity::Queryable
+  end
+end

data/lib/sanity/resources.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "sanity/resources/document"
+require "sanity/resources/asset"

data/lib/sanity/resources/asset.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sanity
+  class Asset < Sanity::Resource
+    mutatable only: %i[create], api_endpoint: "asset/images"
+  end
+end

data/lib/sanity/resources/document.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sanity
+  # Sanity::Document is the core resource for interacting
+  # with Sanity's HTTP API. This class provides out of
+  # the box query and mutation methods for interacting
+  # with the API.
+  #
+  # @example create a new document object in memory
+  #   Sanity::Document.new(_id: 1, _type: "post")
+  #
+  # @example invoke the api operations to create a document
+  #   Sanity::Document.create(params: {_type: "post", title: "A new blog post"})
+  #
+  # @example invoke the api operations to delete a document
+  #   Sanity::Document.delete(params: {id: "1234"})
+  #
+  class Document < Sanity::Resource
+    attribute :_id, default: ""
+    attribute :_type, default: ""
+    # See https://www.sanity.io/docs/http-mutations#ac77879076d4
+    mutatable api_endpoint: "data/mutate"
+    queryable
+  end
+end