sanity-ruby 0.1.0

data/lib/sanity/configuration.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Sanity
+  class Configuration
+    # @return [String] Sanity's project id
+    attr_accessor :project_id
+
+    # @return [String] Sanity's dataset
+    attr_accessor :dataset
+
+    # @return [String] Sanity's api version
+    attr_accessor :api_version
+
+    # @return [String] Sanity's api token
+    attr_accessor :token
+
+    # @return [Boolean] whether to use Sanity's cdn api
+    attr_accessor :use_cdn
+
+    def initialize
+      @project_id = ""
+      @dataset = ""
+      @api_version = ""
+      @token = ""
+      @use_cdn = false
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  class << self
+    alias_method :config, :configuration
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/sanity/groq/filter.rb

@@ -0,0 +1,111 @@
+# 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 Groq
+    class Filter
+      class << self
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      START_PAREN = "("
+      END_PAREN = ")"
+
+      COMPARISON_OPERATORS = {
+        is: "==",
+        not: "!=",
+        gt: ">",
+        gt_eq: ">=",
+        lt: "<",
+        lt_eq: "<=",
+        match: "match"
+      }
+
+      LOGICAL_OPERATORS = {
+        and: "&&",
+        or: "||"
+      }
+
+      RESERVED = COMPARISON_OPERATORS.keys | LOGICAL_OPERATORS.keys
+
+      attr_reader :args, :filter_value
+
+      def initialize(**args)
+        @args = args.except(*Sanity::Groqify::RESERVED - RESERVED)
+        @filter_value = +""
+      end
+
+      def call
+        iterate
+        filter_value.strip
+      end
+
+      private
+
+      def cast_value(val)
+        val.is_a?(Integer) ? val : "'#{val}'"
+      end
+
+      def default_multi_filter
+        filter_value.length.positive? ? " #{LOGICAL_OPERATORS[:and]}" : ""
+      end
+
+      def equal
+        COMPARISON_OPERATORS[:is]
+      end
+
+      def filter(key: nil)
+        key ? " #{multi_filter(key)}" : default_multi_filter.to_s
+      end
+
+      def iterate(arg = args, nested_key: nil)
+        arg.each do |key, val|
+          if val.is_a?(String) || val.is_a?(Integer)
+            filter_value << "#{filter(key: nested_key)} #{key} #{equal} #{cast_value(val)}"
+          elsif val.is_a?(Array) && !val[0].is_a?(Hash)
+            filter_value << "#{key} in #{val.map(&:to_s)}"
+          elsif LOGICAL_OPERATORS.key?(key)
+            if val.is_a?(Array)
+              val.each { |hsh| iterate(hsh, nested_key: key) }
+            elsif LOGICAL_OPERATORS.key?(val.keys[0])
+              filter_value << " #{LOGICAL_OPERATORS[key]} #{START_PAREN}"
+
+              val.values[0].each_with_index do |(vkey, vval), idx|
+                operator = logical_operator(val.keys[0], index: idx)
+                filter_value << "#{operator} " unless operator.empty?
+
+                if vkey.is_a?(Hash)
+                  vkey.each do |vvkey, vvval|
+                    filter_value << "#{vvkey} #{equal} #{cast_value(vvval)}"
+                  end
+                else
+                  filter_value << "#{vkey} #{equal} #{cast_value(vval)}"
+                end
+              end
+
+              filter_value << END_PAREN
+            else
+              iterate(val, nested_key: key)
+            end
+          elsif COMPARISON_OPERATORS.key?(val.keys[0])
+            val.each do |vkey, vval|
+              filter_value << "#{filter(key: nested_key)} #{key} #{COMPARISON_OPERATORS[vkey]} #{cast_value(vval)}"
+            end
+          end
+        end
+      end
+
+      def logical_operator(key, index: 0)
+        index.positive? ? " #{LOGICAL_OPERATORS[key]}" : ""
+      end
+
+      def multi_filter(key)
+        filter_value.length.positive? ? LOGICAL_OPERATORS[key] : ""
+      end
+    end
+  end
+end

data/lib/sanity/groq/order.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Groq
+    class Order
+      class << self
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      RESERVED = %i[order]
+
+      attr_reader :order, :val
+
+      def initialize(**args)
+        args.slice(*RESERVED).then do |opts|
+          @order = opts[:order]
+        end
+
+        @val = +""
+      end
+
+      def call
+        return unless order
+
+        raise ArgumentError, "order must be hash" unless order.is_a?(Hash)
+
+        order.to_a.each_with_index do |(key, sort), idx|
+          val << " | order(#{key} #{sort})".then do |str|
+            idx.positive? ? str : str.strip
+          end
+        end
+
+        val
+      end
+    end
+  end
+end

data/lib/sanity/groq/select.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+using Sanity::Refinements::Arrays
+
+module Sanity
+  module Groq
+    class Select
+      class << self
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      RESERVED = %i[select]
+
+      attr_reader :select, :val
+
+      def initialize(**args)
+        args.slice(*RESERVED).then do |opts|
+          @select = opts[:select]
+        end
+
+        @val = +""
+      end
+
+      def call
+        return unless select
+
+        Array.wrap(select).each_with_index do |x, idx|
+          val << "#{idx.positive? ? "," : ""} #{x}"
+        end
+
+        "{ #{val.strip} }"
+      end
+    end
+  end
+end

data/lib/sanity/groq/slice.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Groq
+    class Slice
+      class << self
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      RESERVED = %i[limit offset]
+      ZERO_INDEX = 0
+
+      attr_reader :limit, :offset
+
+      def initialize(**args)
+        args.slice(*RESERVED).then do |opts|
+          @limit = opts[:limit]
+          @offset = opts[:offset]
+        end
+      end
+
+      def call
+        return "" unless limit
+
+        !offset ? zero_index_to_limit : offset_to_limit
+      end
+
+      private
+
+      def offset_to_limit
+        "[#{offset}...#{limit + offset}]"
+      end
+
+      def zero_index_to_limit
+        "[#{ZERO_INDEX}...#{limit}]"
+      end
+    end
+  end
+end

data/lib/sanity/groqify.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "sanity/groq/filter"
+require "sanity/groq/order"
+require "sanity/groq/slice"
+require "sanity/groq/select"
+
+module Sanity
+  class Groqify
+    class << self
+      def call(**args)
+        new(**args).call
+      end
+    end
+
+    RESERVED = Sanity::Groq::Filter::RESERVED |
+      Sanity::Groq::Slice::RESERVED |
+      Sanity::Groq::Order::RESERVED |
+      Sanity::Groq::Select::RESERVED
+
+    attr_reader :args
+
+    def initialize(**args)
+      @args = args
+    end
+
+    def call
+      "*[#{filter}] #{order} #{slice} #{select}".strip
+    end
+
+    private
+
+    def order
+      Sanity::Groq::Order.call(**args)
+    end
+
+    def select
+      Sanity::Groq::Select.call(**args)
+    end
+
+    def slice
+      Sanity::Groq::Slice.call(**args)
+    end
+
+    def filter
+      Sanity::Groq::Filter.call(**args)
+    end
+  end
+end

data/lib/sanity/http.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require "sanity/http/mutation"
+require "sanity/http/query"
+
+require "sanity/http/create"
+require "sanity/http/create_if_not_exists"
+require "sanity/http/create_or_replace"
+require "sanity/http/delete"
+require "sanity/http/patch"
+
+require "sanity/http/find"
+require "sanity/http/where"
+
+require "sanity/http/results"
+
+module Sanity
+  module Http
+  end
+end

data/lib/sanity/http/create.rb

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

data/lib/sanity/http/create_if_not_exists.rb

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

data/lib/sanity/http/create_or_replace.rb

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

data/lib/sanity/http/delete.rb

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

data/lib/sanity/http/find.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sanity
+  module Http
+    class Find
+      include Sanity::Http::Query
+      delegate find_api_endpoint: :resource_klass
+      alias_method :api_endpoint, :find_api_endpoint
+
+      attr_reader :id
+
+      def initialize(**args)
+        super
+        @id = args.delete(:id)
+      end
+
+      private
+
+      def uri
+        URI("#{base_url}/#{id}")
+      end
+    end
+  end
+end

data/lib/sanity/http/mutation.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+using Sanity::Refinements::Strings
+using Sanity::Refinements::Arrays
+
+module Sanity
+  module Http
+    module Mutation
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+          base.extend(Forwardable)
+          base.delegate(%i[project_id api_version dataset token] => :"Sanity.config")
+          base.delegate(mutatable_api_endpoint: :resource_klass)
+        end
+      end
+
+      module ClassMethods
+        def call(**args)
+          new(**args).call
+        end
+      end
+
+      # See https://www.sanity.io/docs/http-mutations#visibility-937bc4250c79
+      ALLOWED_VISIBILITY = %i[sync async deferred]
+
+      # See https://www.sanity.io/docs/http-mutations#aa493b1c2524
+      REQUEST_KEY = "mutations"
+
+      # See https://www.sanity.io/docs/http-mutations#952b77deb110
+      DEFAULT_QUERY_PARAMS = {
+        return_ids: false,
+        return_documents: false,
+        visibility: :sync
+      }.freeze
+
+      attr_reader :options, :params, :resource_klass, :query_set, :result_wrapper
+
+      def initialize(**args)
+        @resource_klass = args.delete(:resource_klass)
+        @params = args.delete(:params)
+        @query_set = Set.new
+        @result_wrapper = args.delete(:result_wrapper) || Sanity::Http::Results
+
+        raise ArgumentError, "resource_klass must be defined" unless resource_klass
+        raise ArgumentError, "params argument is missing" unless params
+
+        (args.delete(:options) || {}).then do |opts|
+          DEFAULT_QUERY_PARAMS.keys.each do |qup|
+            query_set << [qup, opts.fetch(qup, DEFAULT_QUERY_PARAMS[qup])]
+          end
+        end
+        raise ArgumentError, "visibility argument must be one of #{ALLOWED_VISIBILITY}" unless valid_invisibility?
+      end
+
+      def body_key
+        self.class.name.demodulize.underscore.camelize_lower
+      end
+
+      def call
+        Net::HTTP.post(uri, {"#{REQUEST_KEY}": body}.to_json, headers).then do |result|
+          block_given? ? yield(result_wrapper.call(result)) : result_wrapper.call(result)
+        end
+      end
+
+      private
+
+      def base_url
+        "https://#{project_id}.api.sanity.io/#{api_version}/#{mutatable_api_endpoint}/#{dataset}"
+      end
+
+      def body
+        return Array.wrap({"#{body_key}": params}) if params.is_a?(Hash)
+
+        Array.wrap(params.map { |pam| {"#{body_key}": pam} })
+      end
+
+      def camelize_query_set
+        query_set.to_h.transform_keys do |key|
+          key.to_s.camelize_lower
+        end
+      end
+
+      def headers
+        {
+          "Content-Type": "application/json",
+          Authorization: "Bearer #{token}"
+        }
+      end
+
+      def query_params
+        camelize_query_set.map do |key, val|
+          "#{key}=#{val}"
+        end.join("&")
+      end
+
+      def uri
+        URI(base_url).tap do |obj|
+          obj.query = query_params
+        end
+      end
+
+      def valid_invisibility?
+        ALLOWED_VISIBILITY.include? query_set.to_h[:visibility]
+      end
+    end
+  end
+end