Class: APIQL

Inherits:

Object

• Object
• APIQL

Defined in:

lib/apiql.rb

Defined Under Namespace

Modules: Rails Classes: CacheMissed, Context, Entity, Error, HashEntity

Constant Summary

@@cache =

{}

Instance Attribute Summary

• #context ⇒ Object readonly

  Returns the value of attribute context.

Class Method Summary

• .cache(params) ⇒ Object
• .cacheable(dependencies, attr, expires_in: 31*24*60*60) ⇒ Object
• .drop_cache(obj) ⇒ Object
• .eager_loads(schema) ⇒ Object
• .mount(klass, as: nil) ⇒ Object
• .simple_class?(value) ⇒ Boolean

Instance Method Summary

• #eager_load ⇒ Object
• #initialize(binder, *fields) ⇒ APIQL constructor

  A new instance of APIQL.

• #render(schema) ⇒ Object

Constructor Details

#initialize(binder, *fields) ⇒ APIQL

Returns a new instance of APIQL.

# File 'lib/apiql.rb', line 181

def initialize(binder, *fields)
  @context = ::APIQL::Context.new(binder, *fields)
  @context.inject_delegators(self)
end

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the value of attribute context.

# File 'lib/apiql.rb', line 20

def context
  @context
end

Class Method Details

.cache(params) ⇒ Object

# File 'lib/apiql.rb', line 38

def cache(params)
  request_id = params[:apiql]
  request = params[:apiql_request]

  if request.present?
    request = compile(request)
    ::Rails.cache.write("api-ql-cache-#{request_id}", JSON.generate(request), expires_in: 31*24*60*60)
    @@cache[request_id] = request
    @@cache = {} if(@@cache.count > 1000)
  else
    request = @@cache[request_id]
    request ||= JSON.parse(::Rails.cache.fetch("api-ql-cache-#{request_id}")) rescue nil
    raise CacheMissed unless request.present? && request.is_a?(::Array)
  end

  request
end

.cacheable(dependencies, attr, expires_in: 31*24*60*60) ⇒ Object

# File 'lib/apiql.rb', line 56

def cacheable(dependencies, attr, expires_in: 31*24*60*60)
  dependencies = dependencies.flatten.map { |obj| [obj.class.name, obj.id] }
  name = ['api-ql-cache', dependencies, attr].flatten.join('-')
  begin
    raise if expires_in <= 0
    JSON.parse(::Rails.cache.fetch(name))
  rescue
    (block_given? ? yield : nil).tap { |data| expires_in > 0 && ::Rails.cache.write(name, JSON.generate(data), expires_in: expires_in) }
  end
end

.drop_cache(obj) ⇒ Object

# File 'lib/apiql.rb', line 67

def drop_cache(obj)
  return unless ::Rails.cache.respond_to? :delete_if
  ::Rails.cache.delete_if { |k, v| k =~ /api-ql.*-#{obj.class.name}-#{obj.id}-.*/ }
end

.eager_loads(schema) ⇒ Object

# File 'lib/apiql.rb', line 80

def eager_loads(schema)
  result = []

  schema&.each do |call|
    if call.is_a? Hash
      call.each do |function, sub_schema|
        next if function.include? '('
        function = function.split(':').last.strip if function.include? ':'
        function = function.split('.').first if function.include? '.'

        sub = eager_loads(sub_schema)
        if sub.present?
          result.push(function => sub)
        else
          result.push function
        end
      end
    end
  end

  result
end

.mount(klass, as: nil) ⇒ Object

# File 'lib/apiql.rb', line 24

def mount(klass, as: nil)
  as ||= klass.name.split('::').last.underscore
  as += '.' if as.present?

  klass.instance_methods(false).each do |method|
    klass.alias_method("#{as}#{method}", method)
    klass.remove_method(method) if as.present?
  end

  include klass
end

.simple_class?(value) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/apiql.rb', line 72

def simple_class?(value)
  value.nil? ||
    value.is_a?(TrueClass) || value.is_a?(FalseClass) ||
    value.is_a?(Symbol) || value.is_a?(String) ||
    value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(BigDecimal) ||
    value.is_a?(Hash)
end

Instance Method Details

#eager_load ⇒ Object

# File 'lib/apiql.rb', line 186

def eager_load
  result = @eager_load

  @eager_load = []

  result
end

#render(schema) ⇒ Object

# File 'lib/apiql.rb', line 194

def render(schema)
  result = {}

  schema.each do |call|
    if call.is_a? ::Hash
      call.each do |function, sub_schema|
        reg = function.match(/\A((?<alias>[\w\.\:\!\?]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>.*?)\))?\z/)
        raise Error, function unless reg.present?

        name = reg[:alias] || reg[:name]
        function = reg[:name]
        params = @context.parse_params(reg[:params].presence)

        @eager_load = APIQL::eager_loads(sub_schema)

        data = call_function(function, *params)

        if @eager_load.present? && !data.is_a?(::Hash) && !data.is_a?(::Array)
          if data.respond_to?(:includes)
            data = data.includes(eager_load)
          elsif data.respond_to?(:id)
            data = data.class.includes(eager_load).find(data.id)
          end
        end

        if result[name].is_a? ::Hash
          result = result.deep_merge({
            name => @context.render_value(data, sub_schema)
          })
        else
          result[name] = @context.render_value(data, sub_schema)
        end
      end
    else
      reg = call.match(/\A((?<alias>[\w\.\:\!\?]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>.*?)\))?\z/)
      raise Error, call unless reg.present?

      name = reg[:alias] || reg[:name]
      function = reg[:name]
      params = @context.parse_params(reg[:params].presence)

      @eager_load = []

      data = call_function(function, *params)

      if data.is_a? Array
        if data.any? { |item| !APIQL::simple_class?(item) }
          data = nil
        end
      elsif !APIQL::simple_class?(data)
        data = nil
      end

      if result[name].is_a? ::Hash
        result = result.deep_merge({
          name => data
        })
      else
        result[name] = data
      end
    end
  end

  result
end