Class: APIQL

Inherits:

Object

• Object
• APIQL

Extended by:

CRUD

Defined in:

lib/apiql.rb

Defined Under Namespace

Modules: CRUD, 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
• .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

Methods included from CRUD

model

Constructor Details

#initialize(binder, *fields) ⇒ APIQL

Returns a new instance of APIQL.

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

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 83

def context
  @context
end

Class Method Details

.cache(params) ⇒ Object

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

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

  if request.present?
    request = compile(request)
    redis&.set("api-ql-cache-#{request_id}", request.to_json)
    @@cache = {} if @@cache.count > 1000
    @@cache[request_id] = request
  else
    request = @@cache[request_id]
    request ||= JSON.parse(redis.get("api-ql-cache-#{request_id}")) rescue nil
    raise CacheMissed unless request.present? && request.is_a?(::Array)
  end

  request
end

.eager_loads(schema) ⇒ Object

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

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 89

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 121

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 244

def eager_load
  result = @eager_load

  @eager_load = []

  result
end

#render(schema) ⇒ Object

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

def render(schema)
  result = {}

  schema.map 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 = public_send(function, *params)
        if @eager_load.present? && !data.is_a?(::Hash) && !data.is_a?(::Array)
          if data.respond_to?(:eager_load)
            data = data.eager_load(eager_load)
          elsif data.respond_to?(:id)
            data = data.class.eager_load(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 = public_send(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