lockstep_rails 0.3.22

data/app/concepts/lockstep/api_records/scopes.rb

@@ -0,0 +1,20 @@
+module Lockstep::ApiRecords::Scopes
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def scopes
+      @scopes ||= {}
+    end
+
+    def default_scope(&block)
+      scopes[:default_scope] = block if block_given?
+      scopes[:default_scope]
+    end
+
+    def scope(name, block)
+      scopes[name] = block
+      define_singleton_method name, &block
+    end
+  end
+
+end

data/app/concepts/lockstep/client.rb

@@ -0,0 +1,162 @@
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'socket'
+
+module Lockstep
+  class Client
+
+
+    def self.set_bearer_token(token)
+      RequestStore.store[:lockstep_bearer_token] = token
+      RequestStore.store[:lockstep_api_key] = nil
+
+      true
+    end
+
+    def self.bearer_token
+      RequestStore.store[:lockstep_bearer_token]
+    end
+
+    def self.set_api_key(key)
+      RequestStore.store[:lockstep_api_key] = key
+      RequestStore.store[:lockstep_bearer_token] = nil
+
+      true
+    end
+
+    def self.api_key
+      RequestStore.store[:lockstep_api_key]
+    end
+
+
+    ##
+    # Construct a new Lockstep API client targeting the specified server.
+    #
+    # @param env [string] Either "sbx", "prd", or the URI of the server, ending in a slash (/)
+    def initialize(env)
+      @version = "2022.4.32.0"
+      @env = case env
+             when "sbx"
+               "https://api.sbx.lockstep.io/"
+             when "prd"
+               "https://api.lockstep.io/"
+             else
+               env
+             end
+    end
+
+    ##
+    # Configure this API client to use API key authentication
+    #
+    # @param api_key [string] The [Lockstep Platform API key](https://developer.lockstep.io/docs/api-keys) to use for authentication
+    def with_api_key(api_key)
+      self.class.set_api_key(api_key)
+
+      self
+    end
+
+    ##
+    # Configure this API client to use JWT Bearer Token authentication
+    #
+    # @param bearer_token [string] The [JWT Bearer Token](https://developer.lockstep.io/docs/jwt-bearer-tokens) to use for authentication
+    def with_bearer_token(token)
+      self.class.set_bearer_token(token)
+
+      self
+    end
+
+    def bearer_token
+      self.class.bearer_token
+    end
+
+    def api_key
+      self.class.api_key
+    end
+
+    ##
+    # Configure this API to use an application name
+    #
+    # @param app_name [string] The name of the application
+    def with_app_name(app_name)
+      @app_name = app_name
+    end
+
+    ##
+    # Send a request to the API and return the results
+    #
+    # Sends a request to the
+    def request(method, path, body, params)
+
+      url = URI(@env + path)
+      if !params.nil?
+        url.query = URI.encode_www_form(params)
+      end
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true
+
+      request = case method
+                when :get
+                  Net::HTTP::Get.new(url)
+                when :post
+                  Net::HTTP::Post.new(url)
+                when :patch
+                  Net::HTTP::Patch.new(url)
+                when :put
+                  Net::HTTP::Put.new(url)
+                when :delete
+                  Net::HTTP::Delete.new(url)
+                end
+
+      # Set headers and body for request
+      request["Accept"] = 'application/json'
+      request["Content-Type"] = 'application/*+json'
+      request["SdkType"] = 'Ruby'
+      request["SdkVersion"] = '2022.4.32.0'
+      request["MachineName"] = Socket.gethostname
+      body = body.to_json unless body.is_a?(String)
+      request.body = body
+
+      # If there is an application name
+      if @app_name != nil
+        request["ApplicationName"] = @app_name
+      end
+
+      # Which authentication are we using?
+      if api_key != nil
+        request["Api-Key"] = api_key
+      end
+      if bearer_token != nil
+        request["Authorization"] = 'Bearer ' + bearer_token
+      end
+
+      # Send the request
+      http.request(request)
+    end
+
+    def get(path, params: {})
+      request(:get, path, nil, params)
+    end
+
+    def post(path, body: {}, params: {})
+      request(:post, path, body, params)
+    end
+
+    def patch(path, body: {}, params: {})
+      request(:patch, path, body, params)
+    end
+
+    def put(path, body: {}, params: {})
+      request(:put, path, body, params)
+    end
+
+    def delete(path)
+      request(:delete, path, {}, {})
+    end
+
+    def with_logger(&block)
+      block.call
+    end
+  end
+end

data/app/concepts/lockstep/error.rb

@@ -0,0 +1,50 @@
+class Lockstep::Error
+  # ParseError actually represents both HTTP & parse.com error codes. If the
+  # HTTP response is 400, one can inspect the first element of the error
+  # converted to_array for the HTTP error code and the 2nd element for the
+  # parse error response.
+  attr_accessor :msg, :code, :error
+  
+  # @param [String] an error code, e.g. "400"
+  # @param [Object] an optional error mesg/object.
+  def initialize(code, msg="")
+    @msg = msg
+    @code = code
+    case code.to_s
+    when "111"
+      @error = "Invalid type."
+    when "135"
+      @error = "Unknown device type."
+    when "202"
+      @error = "Username already taken."
+    when "203"
+      @error = "Email already taken."
+    when "400"
+      @error = "Bad Request: The request cannot be fulfilled due to bad syntax."
+    when "401"
+      @error = "Unauthorized: Check your App ID & Master Key."
+    when "403"
+      @error = "Forbidden: You do not have permission to access or modify this."
+    when "408"
+      @error = "Request Timeout: The request was not completed within the time the server was prepared to wait."
+    when "415"
+      @error = "Unsupported Media Type"
+    when "500"
+      @error = "Internal Server Error"
+    when "502"
+      @error = "Bad Gateway"
+    when "503"
+      @error = "Service Unavailable"
+    when "508"
+      @error = "Loop Detected"
+    else
+      @error = "Unknown Error"
+      raise "Parse error #{code}: #{@error} #{@msg}"
+    end
+  end
+  
+  def to_array
+    [ @code, @msg ]
+  end
+  
+end

data/app/concepts/lockstep/exceptions.rb

@@ -0,0 +1,4 @@
+class Lockstep::Exceptions
+  class Lockstep::Exceptions::RecordNotFound < ArgumentError
+  end
+end

data/app/concepts/lockstep/query.rb

@@ -0,0 +1,409 @@
+class Lockstep::Query
+  def initialize(klass)
+    @klass = klass
+  end
+
+  def model
+    @klass
+  end
+
+  # Clone is used as return object as it messes with the OR query in situations like these
+  #   unscoped = Lockstep::Connection.unscoped
+  #   unscoped.where(a: 1).or(unscoped.where(b: 1))
+  #   both the where conditions in the above scenario is modifying the same object causing stack-overflow
+  def clone
+    c = Lockstep::Query.new(@klass)
+    c.criteria.deep_merge!(self.criteria.deep_dup)
+    c
+  end
+
+  def with_clone(&block)
+    c = clone
+    c.instance_exec(&block)
+    c
+  end
+
+  def criteria
+    @criteria ||= { :conditions => [] }
+  end
+
+  def or(query)
+    with_clone do
+      criteria[:conditions] << { type: "or", query: query }
+    end
+  end
+
+  def none
+    with_clone do
+      criteria[:none] = true
+    end
+  end
+
+  def where(args)
+    if args.is_a?(Hash)
+      args.each do |k, v|
+        return none if v.is_a?(Array) and v.blank?
+      end
+    end
+
+    with_clone do
+      criteria[:conditions] << convert_arg(args)
+    end
+  end
+
+  def convert_arg(arg)
+    return arg.to_pointer if arg.is_a?(Lockstep::ApiRecord)
+    return Lockstep::ApiRecord.to_date_object(arg) if arg.is_a?(Time) || arg.is_a?(Date)
+    if arg.is_a?(Hash)
+      arg.keys.each do |key|
+        @klass.valid_attribute?(key, raise_exception: true)
+      end
+      return arg.update(arg) { |key, inner_arg| convert_arg(inner_arg) }
+    end
+
+    arg
+  end
+
+  def limit(limit)
+    with_clone do
+      # If > 1000, set chunking, because large queries over 1000 need it with Parse
+      # criteria[:chunk] = 1000 if limit > 1000
+      criteria[:limit] = limit
+    end
+  end
+
+  def page(page_number)
+    with_clone do
+      criteria[:page_number] = page_number
+    end
+  end
+
+  def include_object(*objects)
+    with_clone do
+      criteria[:include] ||= []
+      criteria[:include] += objects
+      criteria[:include].uniq!
+    end
+  end
+
+  # attr: {customer_name: :desc}
+  def order(*attr)
+    with_clone do
+      criteria[:order] ||= []
+      attr.each do |item|
+        if item.is_a?(Hash)
+          item.each do |k, v|
+            criteria[:order] << "#{k.to_s.camelize.upcase} #{v}"
+          end
+        elsif item.is_a?(String)
+          criteria[:order] << item
+        end
+      end
+    end
+  end
+
+  # attr: {customer_name: :desc}
+  def reorder(attr)
+    with_clone do
+      criteria[:order] = []
+      order(attr)
+    end
+  end
+
+  # Divides the query into multiple chunks if you're running into RestClient::BadRequest errors.
+  def chunk(count = 100)
+    with_clone do
+      criteria[:chunk] = count
+    end
+  end
+
+  # def related_to(obj, key)
+  #   query = { "$relatedTo" => { "object" => obj.to_pointer, "key" => key } }
+  #   criteria[:conditions].merge!(query)
+  #   clone
+  # end
+
+  def build_filter
+    filter = ""
+    criteria[:conditions].each do |condition|
+      if condition.is_a?(Hash)
+        if condition[:type] == "or"
+          filter = build_filter_condition(filter, "OR", condition[:query].build_filter)
+        else
+          condition.each do |key, value|
+            filter = build_filter_condition(filter, "AND", build_filter_query(key, value))
+          end
+        end
+      elsif condition.is_a?(String)
+        filter = build_filter_condition(filter, "AND", condition)
+      end
+    end
+    filter
+  end
+
+  def build_filter_condition(filter, merge_predicate, condition)
+    if filter.present?
+      filter = "(#{filter}) #{merge_predicate} (#{condition})"
+    else
+      filter += condition
+    end
+    filter
+  end
+
+  PREDICATES = {
+    _not_eq: "NE",
+    _eq: "EQ",
+    _gteq: "GE",
+    _gt: "GT",
+    _lteq: "LE",
+    _lt: "LT",
+    _in: "IN",
+    _contains: "CONTAINS",
+    _starts_with: "STARTSWITH",
+    _ends_with: "ENDSWITH",
+    _is: "IS",
+  }.with_indifferent_access
+
+  def build_filter_query(key, value)
+    key = key.to_s unless key.is_a?(String)
+    predicate = "eq" # default
+    PREDICATES.each do |k, p|
+      if key.ends_with?(k)
+        key = key.gsub(k, "")
+        predicate = p
+        break
+      end
+    end
+
+    # Build value
+    if value.is_a?(Array)
+      value = "(#{value.map { |v| v.is_a?(String) ? "'#{v}'" : v }.join(",")})"
+      predicate = "in" if predicate == "eq"
+    elsif value.is_a?(String) and !["NULL", "NOT NULL"].include?(value)
+      value = "'#{value}'"
+    elsif value.nil?
+      predicate = "IS" if predicate == "eq"
+      value = "NULL"
+    end
+
+    "#{key.camelize(:lower)} #{predicate} #{value}"
+  end
+
+  def build_params
+    params = {}
+    params.merge!({ :filter => build_filter }) if criteria[:conditions]
+    # Lockstep Platform API does not support a page size of 1
+    params.merge!({ :pageSize => (criteria[:limit] == 1 ? 2 : criteria[:limit]) }) if criteria[:limit]
+    params.merge!({ :pageNumber => criteria[:page_number] }) if criteria[:page_number]
+    params.merge!({ :include => criteria[:include].join(",") }) if criteria[:include]
+    params.merge!({ :order => criteria[:order].join(",") }) if criteria[:order]
+    params.merge!({ :pageSize => 2 }) if criteria[:count]
+    params.reject! { |k, v| v.blank? }
+    params
+  end
+
+  def execute
+    return [] if criteria[:none]
+    # This code automatically adds all related objects
+    #
+    # if @klass.has_many_relations
+    #   relations = @klass.has_many_relations.select {|k, val| val[:included]}.keys.map { |relation| relation.to_s }
+    #   include_object(*relations)
+    # end
+
+    params = build_params
+
+    return chunk_results(params) if criteria[:chunk]
+
+    get_results(params)
+  end
+
+  def get_results(params = {})
+    resp = @klass.resource.get(@klass.query_path, :params => params)
+
+    return [] if %w(404).include?(resp.code.to_s)
+    # TODO handle non 200 response code. Throwing an exception for now
+    raise StandardError.new("#{resp.code} error while fetching: #{resp.body}") unless %w(201 200).include?(resp.code.to_s)
+
+    if criteria[:count]
+      results = JSON.parse(resp.body)["totalCount"]
+      return results.to_i
+    else
+      results = JSON.parse(resp.body)["records"]
+      results = results[0..(criteria[:limit] - 1)] if criteria[:limit]
+      get_relation_objects results.map { |r|
+        # Convert camelcase to snake-case
+        r = r.transform_keys { |key| key.underscore }
+        @klass.model_name.to_s.constantize.new(r, false)
+      }
+    end
+  end
+
+  def get_relation_objects(objects)
+    return objects if criteria[:include].blank?
+
+    included_objects = criteria[:include].map { |item| item.to_s.downcase }
+
+    if @klass.has_many_relations
+      objects.each do |item|
+        @klass.has_many_relations.each do |relation, relation_config|
+          next unless included_objects.include?(relation.to_s.downcase)
+
+          if !item.attributes.has_key?(relation.to_s)
+            item.attributes[relation.to_s] = Lockstep::RelationArray.new(@klass, [], relation, relation_config[:class_name])
+          elsif !item.attributes[relation].is_a?(Lockstep::RelationArray)
+            item.attributes[relation.to_s] = Lockstep::RelationArray.new(@klass, item.attributes[relation], relation, relation_config[:class_name])
+          end
+        end
+      end
+    end
+
+    objects.each do |item|
+      item.attributes.each do |key, value|
+        if value.is_a?(Array)
+          relation = @klass.has_many_relations[key]
+          next if relation.blank? or !included_objects.include?(key.to_s.downcase)
+
+          value.each do |relation_hash|
+            relation_obj = turn_relation_hash_into_object(relation, relation_hash)
+            value[value.index(relation_hash)] = relation_obj
+          end
+        elsif value.is_a?(Hash)
+          relation = @klass.belongs_to_relations[key]
+          next if relation.blank?
+
+          relation_hash = value
+          relation_obj = turn_relation_hash_into_object(relation, relation_hash)
+          item.attributes[key] = relation_obj
+        end
+      end
+    end
+    objects
+  end
+
+  def chunk_results(params = {})
+    page = criteria[:page] || 0
+    limit = criteria[:limit] || 0
+    # completed = false
+    records = []
+    loop do
+      params[:pageNumber] = page
+      params[:pageSize] = limit > 0 ? [limit - records.size, criteria[:chunk]].min : criteria[:chunk]
+      break if params[:pageSize] == 0
+
+      results = get_results(params)
+      break unless results.present?
+
+      records += results
+      break if limit > 0 and records.size >= limit
+
+      page += 1
+    end
+
+    records
+  end
+
+  def first
+    limit(1)
+    execute.first
+  end
+
+  def all
+    execute
+  end
+
+  def count
+    criteria[:count] = true
+    execute
+  end
+
+  # Find a Lockstep::ApiRecord object by ID
+  #
+  # @param [String] id the ID of the Parse object you want to find.
+  # @return [Lockstep::ApiRecord] an object that subclasses Lockstep::ApiRecord.
+  def find(id)
+    raise Lockstep::Exceptions::RecordNotFound, "Couldn't find #{name} without an ID" if id.blank?
+    record = where(@klass.id_ref => id).first
+    raise Lockstep::Exceptions::RecordNotFound, "Couldn't find #{name} with id: #{id}" if record.blank?
+    record
+  end
+
+  def method_missing(meth, *args, &block)
+    method_name = method_name.to_s
+    if method_name.start_with?("find_by_")
+      attrib = method_name.gsub(/^find_by_/, "")
+      finder_name = "find_all_by_#{attrib}"
+
+      define_singleton_method(finder_name) do |target_value|
+        where({ attrib.to_sym => target_value }).first
+      end
+
+      send(finder_name, args[0])
+    elsif method_name.start_with?("find_all_by_")
+      attrib = method_name.gsub(/^find_all_by_/, "")
+      finder_name = "find_all_by_#{attrib}"
+
+      define_singleton_method(finder_name) do |target_value|
+        where({ attrib.to_sym => target_value }).all
+      end
+
+      send(finder_name, args[0])
+    end
+
+    if @klass.scopes[meth].present?
+      instance_exec *args, &@klass.scopes[meth]
+    elsif Array.method_defined?(meth)
+      all.send(meth, *args, &block)
+    else
+      super
+    end
+  end
+
+  def respond_to?(meth)
+    if Array.method_defined?(meth)
+      true
+    else
+      super
+    end
+  end
+
+  def unscoped
+    Lockstep::Query.new(@klass)
+  end
+
+  private
+
+  def turn_relation_hash_into_object(relation, hash)
+    return nil if hash == nil
+    relation_klass = relation[:class_name].to_s.constantize
+    relation_object = relation_klass.new
+    hash.each do |key, value|
+      class_name_in_a_hash = false
+      if value.is_a?(Array)
+        value.each do |item|
+          if item and item.is_a?(Hash)
+            class_name_in_a_hash = true if relation_klass.has_many_relations[key].present?
+            break
+          end
+        end
+      end
+
+      if value.is_a?(Array) and class_name_in_a_hash
+        value.each do |object_in_array|
+          fresh_object = turn_relation_hash_into_object(relation_klass.has_many_relations[key][:class_name], object_in_array)
+          value[value.index(object_in_array)] = fresh_object
+        end
+        # Convert key from camelcase to snake-case
+        relation_object.attributes[key.underscore] = value
+      elsif value.is_a?(Hash) and relation_klass.belongs_to_relations[key].present?
+        # Convert key from camelcase to snake-case
+        relation_object.attributes[key.underscore] = turn_relation_hash_into_object(relation_klass.belongs_to_relations[key][:class_name], value)
+      else
+        # Convert key from camelcase to snake-case
+        relation_object.attributes[key.underscore] = value if key.to_s != "__type" and key.to_s != "className"
+      end
+    end
+
+    relation_object
+  end
+end