sobjectmodel 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 593a275d93ff933f9e7d9be260194f2da06f4b55285424589b739db5b80e4b8d
+  data.tar.gz: d8723a40b412a472ba84d56658046cde7b320ed617e22c92264d93b8649d5aaa
+SHA512:
+  metadata.gz: 6dda884fe46731a0c8e25b372792908b3e4e43eb1d1a7693e97658cba06eeb6dadbff42ceedc7e04525072fe67b7027de372172ce637e567547b90b879bc799b
+  data.tar.gz: 0cb40fb055300eaef7f198878c12f03652a7d79c70a0bef09ddb9d4b9ac949a92e231912be6ac0ee18d0142e446bbc8a713266d6ef9eaf817af4d2fdaf40815c

data/lib/sobject_model/adapter/base.rb

@@ -0,0 +1,34 @@
+module SObjectModel
+  module Adapter
+    class Base
+      def exec_query(soql, model_class: nil)
+        raise 'this method is not implemented'
+      end
+
+      def find(object_type, id, klass)
+        raise 'this method is not implemented'
+      end
+
+      def create(object_type, values, klass = nil)
+        raise 'this method is not implemented'
+      end
+
+      def update(object_type, id, values)
+        raise 'this method is not implemented'
+      end
+
+      def delete(object_type, id) 
+        raise 'this method is not implemented'
+      end
+
+      def query(soql, klass)
+        raise 'this method is not implemented'
+      end
+
+      def describe(object_type)
+        raise 'this method is not implemented'
+      end
+    end
+  end
+end 
+  

data/lib/sobject_model/adapter/rest.rb

@@ -0,0 +1,53 @@
+require_relative 'base'
+require_relative '../rest/client'
+
+module SObjectModel
+  module Adapter
+    class Rest < Base
+      def initialize(rest_client)
+        @client = rest_client
+      end
+
+      def exec_query(soql, model_class: nil)
+        result = client.query(soql)
+        result.to_records(model_class: model_class)
+      end
+
+      def describe(object_type)
+        client.describe(object_type)
+      end
+
+      def find(object_type, id, klass)
+        attributes = client.find(object_type, id)
+        klass.new(**attributes)
+      rescue ::SObjectModel::Rest::RecordNotFoundError
+        nil
+      end
+
+      def create(object_type, values, klass = nil)
+        id = client.create(object_type, values)
+        return id if klass.nil?
+
+        find(object_type, id, klass)
+      end
+
+      def update(object_type, id, values)
+        client.update(object_type, id, values)
+      end
+
+      def delete(object_type, id)
+        client.delete(object_type, id)
+      end
+
+      def query(soql, klass)
+        exec_query(soql, model_class: klass)
+      end
+
+      private
+
+      def client
+        @client
+      end
+    end
+  end
+end

data/lib/sobject_model/adapter/sf.rb

@@ -0,0 +1,52 @@
+require_relative 'base'
+
+module SObjectModel
+  module Adapter
+    class Sf < Base
+      attr_reader :target_org
+
+      def initialize(sf_main, target_org:)
+        @sf = sf_main
+        @target_org = target_org
+      end
+
+      def exec_query(soql, format: nil, bulk: false, wait: nil, model_class: nil)
+        sf.data.query(soql, target_org: target_org, format: format, bulk: bulk, wait: wait, model_class: model_class)
+      end
+
+      def find(object_type, id, klass)
+        sf.data.get_record object_type, record_id: id, target_org: target_org, model_class: klass
+      end
+
+      def create(object_type, values, klass = nil)
+        id = sf.data.create_record object_type, values: values, target_org: target_org
+        return id if klass.nil?
+
+        find(object_type, id, klass)
+      end
+
+      def update(object_type, id, values)
+        sf.data.update_record object_type, record_id: id, where: nil, values: values, target_org: target_org
+      end
+
+      def delete(object_type, id)
+        sf.data.delete_record object_type, record_id: id, where: nil, target_org: target_org
+      end
+
+      def query(soql, klass, format = nil)
+        sf.data.query soql, target_org: target_org, format: format, model_class: klass
+      end
+
+      def describe(object_type)
+        schema = sf.sobject.describe(object_type, target_org: target_org)
+        schema.to_h # convert to raw command response
+      end
+
+      private
+
+      def sf
+        @sf
+      end
+    end
+  end
+end

data/lib/sobject_model/base_methods.rb

@@ -0,0 +1,57 @@
+module SObjectModel
+  module BaseMethods
+    def self.included(c)
+      c.extend ClassMethods
+    end
+
+    module ClassMethods
+      def connection
+        @connection
+      end
+
+      def connection=(conn)
+        @connection = conn
+      end
+
+      def describe
+        Schema.new(connection.describe(name.to_sym))
+      end
+    end
+
+    def initialize(attributes = {})
+      @original_attributes = {}
+      @current_attributes = {}
+      @updated_attributes = {}
+
+      attributes.each do |k, v|
+        field_name = k.to_sym
+        if self.class.field_names.include?(field_name)
+          @original_attributes[field_name] = v
+          __send__ (field_name.to_s + '='), v
+        elsif self.class.parent_relations.find{|r| r[:name] == field_name}
+          __send__ (field_name.to_s + '='), v
+        elsif self.class.child_relations.find{|r| r[:name] == field_name}
+          __send__ (field_name.to_s + '='), (v.nil? ? [] : v)
+        end
+      end
+    end
+
+    def to_h(keys: nil)
+      self.class.field_names.each_with_object({}) do |name, hash|
+        if keys&.instance_of?(Array)
+          hash[name] = __send__(name) if keys.include?(name)
+        else
+          hash[name] = __send__(name)
+        end
+      end
+    end
+
+    def new_record?
+      self.Id.nil?
+    end
+
+    def persisted?
+      new_record? == false
+    end
+  end
+end

data/lib/sobject_model/class_definition.rb

@@ -0,0 +1,100 @@
+require_relative './schema'
+require_relative './base_methods'
+require_relative './dml_methods'
+require_relative './query_methods'
+
+module SObjectModel
+  class ClassDefinition
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = Schema.new(schema)
+    end
+
+    def to_s
+      <<~Klass
+        Class.new do
+          include ::SObjectModel::BaseMethods
+          include ::SObjectModel::DmlMethods
+          include ::SObjectModel::QueryMethods
+
+          attr_reader :original_attributes, :current_attributes, :updated_attributes
+
+          #{ class_methods }
+
+          #{ field_attribute_methods }
+          #{ parent_relation_methods }
+          #{ child_relation_methods }
+        end
+      Klass
+    end
+
+    def class_methods
+      <<~EOS
+        class << self
+          def field_names
+            @field_names ||= #{ schema.field_names }
+          end
+
+          def parent_relations
+            @parent_relations ||= #{ schema.parent_relations }
+          end
+
+          def child_relations
+            @child_relations ||= #{ schema.child_relations }
+          end
+        end
+      EOS
+    end
+
+    def field_attribute_methods
+      schema.field_names.each_with_object('') do |name, s|
+        s << <<~EOS
+          def #{name}
+            @#{name}
+          end
+
+          def #{name}=(value)
+            @#{name} = value
+            return if %i[Id LastModifiedDate IsDeleted SystemModstamp CreatedById CreatedDate LastModifiedById].include?(:#{name})
+
+            current_attributes[:#{name}] = value
+            if current_attributes[:#{name}] == original_attributes[:#{name}]
+              updated_attributes[:#{name}] = nil
+            else
+              updated_attributes[:#{name}] = (value.nil? ? :null : value)
+            end
+          end
+        EOS
+      end
+    end
+
+    def parent_relation_methods
+      schema.parent_relations.each_with_object('') do |r, s|
+        s << <<~EOS
+          def #{r[:name]}
+            @#{r[:name]}
+          end
+
+          def #{r[:name]}=(attributes)
+            @#{r[:name]} = attributes.nil? ? nil : #{r[:class_name]}.new(attributes)
+          end
+        EOS
+      end
+    end
+
+    def child_relation_methods
+      schema.child_relations.each_with_object('') do |r, s|
+        s << <<~EOS
+          def #{r[:name]}
+            @#{r[:name]}
+          end
+
+          def #{r[:name]}=(records)
+            @#{r[:name]} = records.map{|attributes| #{r[:class_name]}.new(attributes)}
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/sobject_model/dml_methods.rb

@@ -0,0 +1,37 @@
+module SObjectModel
+  module DmlMethods
+    def self.included(c)
+      c.extend ClassMethods
+    end
+
+    def save
+      if new_record?
+        self.Id = self.class.connection.create(self.class.name.to_sym, current_attributes.reject{|_,v| v.nil?})
+      else
+        _updated_attributes =
+          updated_attributes
+            .reject{|_,v| v.nil?}
+            .each_with_object({}){ |(k,v),h| h[k] = (v == :null) ? nil : v }
+
+        self.class.connection.update(self.class.name.to_sym, self.Id, _updated_attributes)
+      end
+
+      @original_attributes = current_attributes.dup
+      @updated_attributes = {}
+
+      self.Id
+    end
+
+    def delete
+      return if self.Id.nil?
+
+      self.class.connection.delete(self.class.name.to_sym, self.Id)
+    end
+
+    module ClassMethods
+      def create(values = {})
+        connection.create(name.to_sym, values, Object.const_get(name.to_sym))
+      end
+    end
+  end
+end

data/lib/sobject_model/generator.rb

@@ -0,0 +1,45 @@
+require_relative './class_definition'
+
+module SObjectModel
+  class Generator
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def connected?
+      connection.nil? == false
+    end
+
+    def generate(*object_types)
+      generated_types = []
+      object_types.each do |object_type|
+        next if generated? object_type
+
+        schema = describe(object_type)
+        class_definition = ClassDefinition.new(schema)
+
+        instance_eval "::#{object_type} = #{class_definition}"
+        klass = Object.const_get object_type.to_sym
+        klass.connection = connection
+        generated_types << object_type
+      end
+
+      generated_types
+    end
+
+    private
+
+    def describe(object_type)
+      connection.describe object_type
+    end
+
+    def generated?(object_type)
+      Object.const_get object_type.to_sym
+      true
+    rescue NameError
+      false
+    end
+  end
+end

data/lib/sobject_model/query_condition.rb

@@ -0,0 +1,189 @@
+require 'date'
+
+module SObjectModel
+  module QueryMethods
+    class QueryCondition
+      attr_reader :connection,
+                  :object_name,
+                  :all_field_names,
+                  :fields,
+                  :conditions,
+                  :limit_num,
+                  :row_order,
+                  :count_select,
+                  :max_select_field,
+                  :min_select_field
+
+      def initialize(connection, object_name, field_names)
+        @object_name = object_name
+        @all_field_names = field_names 
+        @connection = connection
+        @fields = []
+        @conditions = [] 
+        @limit_num = nil
+        @row_order = nil
+        @count_select = false
+        @max_select_field = nil
+        @min_select_field = nil
+      end
+
+      def where(*expr)
+        return self unless valid_expr?(expr)
+
+        conditions.append to_string_expr(expr)
+        self
+      end
+
+      def not(*expr)
+        return self unless valid_expr?(expr)
+
+        conditions.append %|(NOT(#{to_string_expr(expr)}))|
+        self
+      end
+
+      def select(*expr)
+        return self if expr&.empty?
+
+        if expr.size > 1
+          @fields = self.fields + expr
+        else
+          self.fields << expr.first
+        end
+        return self
+      end
+
+      def limit(num)
+        @limit_num = num
+        return self
+      end
+
+      def order(*_fields)
+        return self if _fields&.empty?
+
+        @row_order = _fields
+        return self
+      end
+
+      def to_soql
+        base   = 'SELECT %{select} FROM %{object}' % {select: select_fields, object: object_name}
+        where  = conditions.size.zero?  ? nil : 'WHERE %{where}'    % {where: conditions.flatten.join(' AND ')}
+        _order = row_order.nil?         ? nil : 'ORDER BY %{order}' % {order: row_order.join(', ')}
+        limit  = limit_num.nil?         ? nil : 'LIMIT %{limit}'    % {limit: limit_num} 
+
+        [base, where, _order, limit].compact.join(' ')
+      end
+
+      def all
+        connection.query(to_soql, Object.const_get(object_name.to_sym))
+      end
+
+      def pluck(field_name)
+        connection.query(to_soql, nil).map{|record| record[field_name.to_s]}
+      end
+
+      def take
+        limit(1).all.first
+      end
+
+      def count
+        @count_select = true
+        connection.query(to_soql, nil).first['expr0']
+      end
+
+      def max(field_name)
+        @max_select_field = field_name
+        connection.query(to_soql, nil).first['expr0']
+      end
+
+      def min(field_name)
+        @min_select_field = field_name
+        connection.query(to_soql, nil).first['expr0']
+      end
+
+      private
+
+      def select_fields
+        return 'COUNT(Id)'                if count_select
+        return "MAX(#{max_select_field})" if max_select_field
+        return "MIN(#{min_select_field})" if min_select_field
+
+        (fields.empty? ? all_field_names : fields.push(:Id).uniq).join(', ')
+      end 
+
+      def to_string_expr(expr)
+        return str_by_ternary_expr(expr) if expr.size > 1
+        return expr[0] if expr[0].instance_of? String
+
+        strs_by_hash_expr(expr)
+      end
+
+      def str_by_ternary_expr(expr)
+        return self if expr.size < 3
+
+        value = case expr[2].class.name.to_sym
+                when :String
+                  %|'#{expr[2]}'|
+                when :Time
+                  expr[2].to_datetime
+                when :NilClass
+                  :null
+                when :Array
+                  candidates = expr[2].map do |o|
+                      case o.class.name.to_sym
+                      when :String
+                        %|'#{o}'|
+                      when :Time
+                        o.to_datetime
+                      when :NilClass
+                        :null
+                      else
+                        o
+                      end
+                    end
+                  %|(#{candidates.join(', ')})|
+                else
+                  expr[2]
+                end
+        %|#{expr[0]} #{expr[1]} #{value}|
+      end
+
+      def valid_expr?(expr)
+        return false if expr&.empty?
+        return false if expr.map{|o| (o == '' || o == {} || o == []) ? nil : o}.compact.size.zero?
+        return false unless [Hash, Symbol, String].any?{|klass| expr.first.instance_of? klass}
+
+        true
+      end
+
+      def strs_by_hash_expr(expr)
+        expr[0].map do |k,v|
+          case v.class.name.to_sym
+          when :String
+            %|#{k} = '#{v}'|
+          when :Time
+            %|#{k} = #{v.to_datetime}|
+          when :NilClass
+            %|#{k} = null|
+          when :Array
+            candidates = v.map do |o|
+                case o.class.name.to_sym
+                when :String
+                  %|'#{o}'|
+                when :Time
+                  %|#{o.to_datetime}|
+                when :NilClass
+                  :null
+                else
+                  o
+                end
+              end
+            %|#{k} IN (#{candidates.join(', ')})|
+          else
+            "#{k} = #{v}"
+          end
+        end
+        .join(' AND ')
+      end
+    end
+  end
+end

data/lib/sobject_model/query_methods.rb

@@ -0,0 +1,78 @@
+require_relative './query_condition'
+
+module SObjectModel
+  module QueryMethods
+    def self.included(c)
+      c.extend ClassMethods
+    end
+
+    module ClassMethods
+      def where(*expr)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.where(*expr)
+        return qc
+      end
+
+      def select(*fields)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.select(*fields)
+        return qc
+      end
+
+      def limit(num)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.limit(num)
+        qc
+      end
+
+      def order(*field_names)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.order(*field_names)
+        qc
+      end
+      def find(id)
+        connection.find(name.to_sym, id, Object.const_get(name.to_sym))
+      end
+
+      def find_by(*find_condition)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.where(*find_condition).take
+      end
+
+      def all
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.all
+      end
+
+      def to_csv
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.to_csv
+      end
+
+      def pluck(field_name)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.pluck(field_name)
+      end
+
+      def take
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.take
+      end
+
+      def count
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.count
+      end
+
+      def max(field_name)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.max(field_name)
+      end
+
+      def min(field_name)
+        qc = QueryCondition.new(connection, self.name, self.field_names)
+        qc.min(field_name)
+      end
+    end
+  end
+end