sf_cli 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f11658c0b90ce494643c625b80f6826ec42597723315fd52690aefc6d97c8c
-  data.tar.gz: e0318c64547346287a378766a3441249cf2906539693bc982e486d6bca4b7836
+  metadata.gz: a3e5833449ce9819bd4c28f92d21d2719cfac0bd9b6a0917f61de212b3b1a485
+  data.tar.gz: 34c71983f1f8feae1dec31b965e9ef1102ea1b4340eb0ebaffa376df8c1cc699
 SHA512:
-  metadata.gz: 57c9f53f54298b2bcb7e566bceb48704012154c6a160e08402eb48d998cd2dc361d1f021bedb7866fade1beecfddab30affb0dcffa812cdfb20b7b6417c69df5
-  data.tar.gz: 875b18097589d7f4df8a212a078bbaf98e35de738782a8d4522f2a198861f280457ed23828838a77c645d170305423985edc16ee4e23ef77bd0afaeb8f0986af
+  metadata.gz: 62d251ef5a3411ec98a835de03f686e45551eb783d6504772ba56abc8eff986b95d0d70f37257479934a670e279656b047326faf623845879cc7f4e797bdae80
+  data.tar.gz: 25b30fd9cc789d55be2d8f15903b72e16d7bcf03447402782be48f738a8d00bf71270972c47a776df0ce2c59d801bea880ffc1c46e557d8837cc67e32b216406

data/lib/sf_cli/sf/model/query_condition.rb

@@ -6,7 +6,16 @@ module SfCli
       module QueryMethods
         # @private :nodoc: just for developers
         class QueryCondition
-          attr_reader :connection, :object_name, :all_field_names, :fields, :conditions, :limit_num, :row_order
+          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
@@ -16,71 +25,23 @@ module SfCli
             @conditions = [] 
             @limit_num = nil
             @row_order = nil
+            @count_select = false
+            @max_select_field = nil
+            @min_select_field = nil
           end
 
           def where(*expr)
-            return self if expr&.empty?
-            return self if expr.map{|o| (o == '' || o == {} || o == []) ? nil : o}.compact.size.zero?
-            return self unless [Hash, Symbol, String].any?{|klass| expr.first.instance_of? klass}
+            return self unless valid_expr?(expr)
 
-            if expr.size > 1
-              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 :Array
-                        candidates = expr[2].map do |o|
-                            case o.class.name.to_sym
-                            when :String
-                              %|'#{o}'|
-                            when :Time
-                              o.to_datetime
-                            else
-                              o
-                            end
-                          end
-                        %|IN (#{candidates.join(', ')})|
-                      else
-                        expr[2]
-                      end
-              conditions << %|#{expr[0]} #{expr[1]} #{value}|
-
-              return self
-            end
+            conditions.append to_string_expr(expr)
+            self
+          end
 
-            if expr[0].instance_of? String
-              conditions << expr[0]
-              return self
-            end
+          def not(*expr)
+            return self unless valid_expr?(expr)
 
-            new_conditions =
-              expr[0].map do |k,v| 
-                case v.class.name.to_sym
-                when :String
-                  %|#{k} = '#{v}'|
-                when :Time
-                  %|#{k} = #{v.to_datetime}|
-                when :Array
-                  candidates = v.map do |o|
-                      case o.class.name.to_sym
-                      when :String
-                        %|'#{o}'|
-                      when :Time
-                        %|#{o.to_datetime}|
-                      else
-                        o
-                      end
-                    end
-                  %|#{k} IN (#{candidates.join(', ')})|
-                else
-                  "#{k} = #{v}"
-                end
-              end
-            conditions.append new_conditions
-            return self
+            conditions.append %|NOT(#{to_string_expr(expr)})|
+            self
           end
 
           def select(*expr)
@@ -115,21 +76,113 @@ module SfCli
             [base, where, _order, limit].compact.join(' ')
           end
 
+          def to_csv
+            connection.query(to_soql, Object.const_get(object_name.to_sym), :csv)
+          end
+
           def all
             connection.query(to_soql, Object.const_get(object_name.to_sym))
           end
 
           def pluck(field_name)
-            all.map{|record| record.__send__(field_name.to_sym)}
+            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).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 :Array
+                      candidates = expr[2].map do |o|
+                          case o.class.name.to_sym
+                          when :String
+                            %|'#{o}'|
+                          when :Time
+                            o.to_datetime
+                          else
+                            o
+                          end
+                        end
+                      %|IN (#{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 :Array
+                candidates = v.map do |o|
+                    case o.class.name.to_sym
+                    when :String
+                      %|'#{o}'|
+                    when :Time
+                      %|#{o.to_datetime}|
+                    else
+                      o
+                    end
+                  end
+                %|#{k} IN (#{candidates.join(', ')})|
+              else
+                "#{k} = #{v}"
+              end
+            end
+            .join(' AND ')
+          end
         end
       end
     end

data/lib/sf_cli/sf/model/query_methods.rb

@@ -22,15 +22,6 @@ module SfCli
             return 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 limit(num)
             qc = QueryCondition.new(connection, self.name, self.field_names)
             qc.limit(num)
@@ -43,11 +34,25 @@ module SfCli
             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)
@@ -57,6 +62,21 @@ module SfCli
             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

data/lib/sf_cli/sf/model/sf_command_connection.rb

@@ -65,8 +65,8 @@ module SfCli
         end
 
         # @private :nodoc: just for developers
-        def query(soql, klass)
-          sf_data.query soql, target_org: target_org, model_class: klass
+        def query(soql, klass, format = nil)
+          sf_data.query soql, target_org: target_org, format: format, model_class: klass
         end
 
         # @private :nodoc: just for developers

data/lib/sf_cli/sf/sobject/describe.rb

@@ -13,8 +13,8 @@ module SfCli::Sf::Sobject
     #   schema = sf.sobject.describe :Account
     #   schema.name  # Account
     #   schema.label # Account
-    #   schema.field_names # [:Id, :Name, ....]
-    #   schema.fields[:Name] # => {"aggregatable"=>true, "aiPredictionField"=>false, "autoNumber"=>false,...}
+    #   schema.field_names            # [:Id, :Name, ....]
+    #   schema.fields.name_and_labels # [['Id', 'Account Id'], ['Name', 'Account Name'], ...]
     #
     # @see https://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_reference.meta/sfdx_cli_reference/cli_reference_sobject_commands_unified.htm#cli_reference_sobject_describe_unified command reference
     #

data/lib/sf_cli/sf/sobject/schema.rb

@@ -2,32 +2,28 @@ module SfCli
   module Sf
     module Sobject
       class Schema
-        attr_reader :schema
-
         def initialize(schema)
           @schema = schema
         end
 
-        def all
-          schema
-        end
-
         def name
-          @name ||= schema['name']
+          schema['name']
         end
 
         def label
-          @label ||= schema['label']
+          schema['label']
+        end
+
+        def fields
+          @fields ||= Fields.new(schema)
         end
 
         def field_names
-          @field_names ||= schema['fields'].map{|f| f['name'].to_sym}
+          @field_names ||= fields.map{|f| f.name.to_sym}
         end
 
-        def fields
-          @field_map ||= schema['fields'].each_with_object({}) do |f, h|
-            h[f['name'].to_sym] = f
-          end
+        def field_labels
+          @field_labels ||= fields.map{|f| f.label}
         end
 
         def children_relations
@@ -37,9 +33,449 @@ module SfCli
         end
 
         def parent_relations
-          schema['fields']
-            .select{|f| f['relationshipName'].nil? == false && f['referenceTo']&.size > 0}
-            .map{|f| {name: f['relationshipName'].to_sym, field: f['name'].to_sym, class_name: f['referenceTo'].first.to_sym}}
+          fields
+            .select{|f| !(f.relationship_name.nil? || f.reference_to.nil?) && f.reference_to.size > 0}
+            .map{|f| {name: f.relationship_name.to_sym, field: f.name.to_sym, class_name: f.reference_to.first.to_sym} }
+        end
+
+        def to_h
+          schema
+        end
+
+        def compact_layoutable?
+          schema["compactLayoutable"]
+        end
+
+        def createable?
+          schema["createable"]
+        end
+
+        def custom?
+          schema["custom"]
+        end
+
+        def custom_setting?
+          schema["customSetting"]
+        end
+
+        def deep_cloneable?
+          schema["deepCloneable"]
+        end
+
+        def default_implementation
+          schema["defaultImplementation"]
+        end
+
+        def deletable?
+          schema["deletable"]
+        end
+
+        def deprecated_and_hidden?
+          schema["deprecatedAndHidden"]
+        end
+
+        def extended_by
+          schema["extendedBy"]
+        end
+
+        def extends_interfaces
+          schema["extendsInterfaces"]
+        end
+
+        def feed_enabled?
+          schema["feedEnabled"]
+        end
+
+        def has_subtypes?
+          schema["hasSubtypes"]
+        end
+
+        def implemented_by
+          schema["implementedBy"]
+        end
+
+        def implements_interfaces
+          schema["implementsInterfaces"]
+        end
+
+        def interface?
+          schema["isInterface"]
+        end
+
+        def subtype?
+          schema["isSubtype"]
+        end
+
+        def key_prefix
+          schema["keyPrefix"]
+        end
+
+        def label_plural
+          schema["labelPlural"]
+        end
+
+        def layoutable?
+          schema["layoutable"]
+        end
+
+        def listviewable?
+          schema["listviewable"]
+        end
+
+        def lookup_layoutable
+          schema["lookupLayoutable"]
+        end
+
+        def mergeable?
+          schema["mergeable"]
+        end
+
+        def mruEnabled
+          schema["mruEnabled"]
+        end
+
+        def named_layouts
+          schema["namedLayoutInfos"]
+        end
+
+        def network_scope_field_name
+          schema["networkScopeFieldName"]
+        end
+
+        def queryable?
+          schema["queryable"]
+        end
+
+        def record_types
+          schema["recordTypeInfos"]
+        end
+
+        def replicateable?
+          schema["replicateable"]
+        end
+
+        def retrieveable?
+          schema["retrieveable"]
+        end
+
+        def search_layoutable?
+          schema["searchLayoutable"]
+        end
+
+        def searchable?
+          schema["searchable"]
+        end
+
+        def sobject_describe_option
+          schema["sobjectDescribeOption"]
+        end
+
+        def supported_scopes
+          schema["supportedScopes"]
+        end
+
+        def triggerable?
+          schema["triggerable"]
+        end
+
+        def undeletable?
+          schema["undeletable"]
+        end
+
+        def updateable?
+          schema["updateable"]
+        end
+
+        def urls
+          schema["urls"]
+        end
+
+        private
+
+        def schema
+          @schema
+        end
+
+        class Fields
+          include Enumerable
+
+          def initialize(schema)
+            @fields = schema['fields'].map{|h| Field.new(**h)}
+          end
+
+          def each(&block)
+            fields.each &block
+          end
+
+          def to_a
+            fields
+          end
+
+          def find_by(name: nil, label: nil)
+            return nil if name.nil? && label.nil?
+
+            attr_name = name.nil? ? :label : :name
+            val       = name || label
+
+            find do |field|
+              attr_val = field.__send__(attr_name.to_sym)
+              attr_val == val
+            end
+          end
+
+          def name_and_labels
+            map{|field| [field.name, field.label]}
+          end
+
+          private
+
+          def fields
+            @fields
+          end
+        end
+
+        class Field
+          def initialize(field)
+            @field = field
+          end
+
+          def aggregatable?
+            field["aggregatable"]
+          end
+
+          def ai_prediction_field?
+            field["aiPredictionField"]
+          end
+
+          def autoNumber?
+            field["autoNumber"]
+          end
+
+          def byteLength
+            field["byteLength"]
+          end
+
+          def calculated?
+            field["calculated"]
+          end
+
+          def calculated_formula
+            field["calculatedFormula"]
+          end
+
+          def cascade_delete?
+            field["cascadeDelete"]
+          end
+
+          def case_sensitive
+            field["caseSensitive"]
+          end
+
+          def compound_field_name
+            field["compoundFieldName"]
+          end
+
+          def controller_name
+            field["controllerName"]
+          end
+
+          def createable?
+            field["createable"]
+          end
+
+          def custom?
+            field["custom"]
+          end
+
+          def default_value
+            field["defaultValue"]
+          end
+
+          def default_value_formula
+            field["defaultValueFormula"]
+          end
+
+          def defaulted_on_create?
+            field["defaultedOnCreate"]
+          end
+
+          def dependent_picklist?
+            field["dependentPicklist"]
+          end
+
+          def deprecated_and_hidden?
+            field["deprecatedAndHidden"]
+          end
+
+          def digits
+            field["digits"]
+          end
+
+          def display_location_in_decimal?
+            field["displayLocationInDecimal"]
+          end
+
+          def encrypted?
+            field["encrypted"]
+          end
+
+          def external_id?
+            field["externalId"]
+          end
+
+          def extra_type_info
+            field["extraTypeInfo"]
+          end
+
+          def filterable?
+            field["filterable"]
+          end
+
+          def filtered_lookup_info
+            field["filteredLookupInfo"]
+          end
+
+          def formula_treat_null_number_as_zero?
+            field["formulaTreatNullNumberAsZero"]
+          end
+
+          def groupable?
+            field["groupable"]
+          end
+
+          def high_scale_number?
+            field["highScaleNumber"]
+          end
+
+          def html_formatted?
+            field["htmlFormatted"]
+          end
+
+          def id_lookup?
+            field["idLookup"]
+          end
+
+          def inline_help_text
+            field["inlineHelpText"]
+          end
+
+          def label
+            field["label"]
+          end
+
+          def length
+            field["length"]
+          end
+
+          def mask
+            field["mask"]
+          end
+
+          def mask_type
+            field["maskType"]
+          end
+
+          def name
+            field["name"]
+          end
+
+          def name_field?
+            field["nameField"]
+          end
+
+          def name_pointing?
+            field["namePointing"]
+          end
+
+          def nillable?
+            field["nillable"]
+          end
+
+          def permissionable?
+            field["permissionable"]
+          end
+
+          def picklist_values
+            field["picklistValues"]
+          end
+
+          def polymorphic_foreign_key?
+            field["polymorphicForeignKey"]
+          end
+
+          def precision
+            field["precision"]
+          end
+
+          def query_by_distance?
+            field["queryByDistance"]
+          end
+
+          def reference_target_field
+            field["referenceTargetField"]
+          end
+
+          def reference_to
+            field["referenceTo"]
+          end
+
+          def relationship_name
+            field["relationshipName"]
+          end
+
+          def relationship_order
+            field["relationshipOrder"]
+          end
+
+          def restricted_delete
+            field["restrictedDelete"]
+          end
+
+          def restricted_picklist?
+            field["restrictedPicklist"]
+          end
+
+          def scale
+            field["scale"]
+          end
+
+          def search_prefilterable?
+            field["searchPrefilterable"]
+          end
+
+          def soapType
+            field["soapType"]
+          end
+
+          def sortable?
+            field["sortable"]
+          end
+
+          def type
+            field["type"]
+          end
+
+          def unique?
+            field["unique"]
+          end
+
+          def updateable?
+            field["updateable"]
+          end
+
+          def write_Requires_Master_Read?
+            field["writeRequiresMasterRead"]
+          end
+
+          def to_h
+            field
+          end
+
+          private
+
+          def field
+            @field
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sf_cli
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Takanobu Maekawa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-23 00:00:00.000000000 Z
+date: 2024-09-24 00:00:00.000000000 Z
 dependencies: []
 description: A class library for introducing Salesforce CLI to Ruby scripting. Currenty
   only sf command is the target of development.