runapi-core 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3716e984b8648825f23f5dba6a64e015ff70bf1c1f5711f96f0c41f57f8184f9
-  data.tar.gz: cbe52d93ce9609dd55da08d45bba595c8f95cebd80c24db7774a9be0765c3fb8
+  metadata.gz: ad3b0781bacf4ae45f6fe15948391c47a7ba0e8a37ea9481af61c1faef44a881
+  data.tar.gz: 619dd3f7627899141c3072acf45aaeeaeafd4b312d974a4b5fd0982953967911
 SHA512:
-  metadata.gz: 9499a9cc754db6ff4eaca48fb10f34216adee0beda90582724c0030c0caa486ee93effcbe8e04cab95fd3d3d253639f454b102b786019b27d085767df2d8f0ad
-  data.tar.gz: 644da423fc25d2eabb33d974012f18f46aa8f445efa34e901e9e3587107afdf37c43af091e8b82f2672c8538d4f4a8896a9df29c668762341fd7f697f702909a
+  metadata.gz: 63b482c33a6a4fc50ea8a85f147735a155b6d7c6365be3e3cd71e032bde911da9864d072ba22ed324278a2dcc9033445b3ddf66d11c0245563091305870b832e
+  data.tar.gz: eaff58ff1a0ab6c1d5c613666acf32b78d74a73a1a998d5bd8842aacad5ee3bb34eadf142f64a52dbe2f24ab75ad7c5c4b529e422eece2bae32fe3f2628ae622

data/lib/runapi/core/resource_helpers.rb

@@ -40,224 +40,6 @@ module RunApi
         params[key.to_s] if params.key?(key.to_s)
       end
 
-      def validate_optional!(params, key, allowed)
-        value = param(params, key)
-        return unless value
-
-        unless allowed.include?(value)
-          raise Core::ValidationError, "Invalid #{key}: #{value}. Must be one of: #{allowed.join(", ")}"
-        end
-      end
-
-      # ---- Contract validation ------------------------------------------
-      # Validates request params against the generated contract: model
-      # membership, then declared cross-field rules, then per-field
-      # required/enum/integer/min/max/length. `schema` is one action entry from the generated
-      # per-package CONTRACT (CONTRACT["<action>"]).
-
-      def validate_contract!(schema, params)
-        model = param_value(params, "model")
-        models = schema["models"] || []
-        if models.empty?
-          fields = schema.dig("fields_by_model", "_") || {}
-        else
-          unless models.include?(model)
-            raise Core::ValidationError, "model must be one of: #{models.sort.join(", ")}"
-          end
-
-          fields = schema.dig("fields_by_model", model) || {}
-        end
-
-        Array(schema["rules"]).each { |rule| enforce_contract_rule!(params, rule) }
-        fields.each do |field, rules|
-          validate_schema_field!(params, field, rules)
-        end
-      end
-
-      def validate_schema_field!(params, field, rules)
-        value = param_value(params, field)
-        if !value.nil? && (rules.key?("min_items") || rules.key?("max_items"))
-          validate_schema_item_count!(field, value, rules)
-        end
-
-        present = field_present?(params, field)
-        raise Core::ValidationError, "#{field} is required" if rules["required"] && !present
-        return unless present
-
-        if (enum = rules["enum"]) && !enum_value_allowed?(enum, value)
-          raise Core::ValidationError, "#{field} must be one of: #{enum.join(", ")}"
-        end
-
-        validate_schema_integer!(field, value, rules) if rules["type"] == "integer"
-        validate_schema_range!(field, value, rules) if rules.key?("min") || rules.key?("max")
-      end
-
-      def validate_schema_item_count!(field, value, rules)
-        raise Core::ValidationError, "#{field} must be an array" unless value.is_a?(Array)
-
-        min = rules["min_items"]
-        max = rules["max_items"]
-        return if (min.nil? || value.size >= min) && (max.nil? || value.size <= max)
-
-        raise Core::ValidationError, item_count_message(field, min, max)
-      end
-
-      def item_count_message(field, min, max)
-        if min && max
-          "#{field} must contain between #{min} and #{max} items"
-        elsif min
-          "#{field} must contain at least #{min} items"
-        else
-          "#{field} must contain at most #{max} items"
-        end
-      end
-
-      # Mirrors GatewayEntry#validate_schema_integer!: a type: integer field
-      # rejects non-integer numbers (e.g. 11.5), which min/max alone admit.
-      def validate_schema_integer!(field, value, rules)
-        return if value.is_a?(Integer)
-
-        min = rules["min"]
-        max = rules["max"]
-        detail = (min && max) ? " between #{min} and #{max}" : ""
-        raise Core::ValidationError, "#{field} must be an integer#{detail}"
-      end
-
-      def validate_schema_range!(field, value, rules)
-        if rules["length"]
-          measured = value.to_s.length
-          unit = "characters"
-        else
-          raise Core::ValidationError, "#{field} must be a number" unless value.is_a?(Numeric)
-
-          measured = value
-          unit = nil
-        end
-
-        min = rules["min"]
-        max = rules["max"]
-        return if (min.nil? || measured >= min) && (max.nil? || measured <= max)
-
-        raise Core::ValidationError, schema_range_message(field, min, max, unit)
-      end
-
-      def schema_range_message(field, min, max, unit)
-        suffix = unit ? " #{unit}" : ""
-        if min && max
-          "#{field} must be between #{min} and #{max}#{suffix}"
-        elsif min
-          "#{field} must be at least #{min}#{suffix}"
-        else
-          "#{field} must be at most #{max}#{suffix}"
-        end
-      end
-
-      def enum_value_allowed?(enum, value)
-        enum.any? do |allowed|
-          if allowed == true || allowed == false
-            value == allowed
-          elsif allowed.is_a?(Numeric)
-            value.is_a?(Numeric) && value == allowed
-          elsif value.is_a?(Numeric)
-            allowed == value
-          else
-            allowed.to_s == value.to_s
-          end
-        end
-      end
-
-      def enforce_contract_rule!(params, rule)
-        conditions = rule["when"] || {}
-        return unless conditions.all? { |field, condition| rule_condition_met?(params, field, condition) }
-
-        # Sorted so the message matches every other SDK; Go maps have no declaration order.
-        context = conditions.sort_by { |field, _| field.to_s }
-          .map { |field, condition| rule_condition_label(field, condition) }.join(" and ")
-        qualifier = context.empty? ? "" : " when #{context}"
-
-        Array(rule["required"]).each do |field|
-          next if field_present?(params, field)
-
-          raise Core::ValidationError, "#{field} is required#{qualifier}"
-        end
-
-        required_any = Array(rule["required_any"])
-        if required_any.any? && required_any.none? { |field| field_present?(params, field) }
-          raise Core::ValidationError, "one of #{required_any.join(", ")} is required#{qualifier}"
-        end
-
-        Array(rule["forbidden"]).each do |field|
-          next unless field_present?(params, field)
-
-          raise Core::ValidationError, "#{field} is not allowed#{qualifier}"
-        end
-
-        (rule["enum"] || {}).sort_by { |field, _| field.to_s }.each do |field, allowed|
-          next unless field_present?(params, field)
-
-          value = param_value(params, field)
-          next if Array(allowed).any? { |candidate| candidate.to_s == value.to_s }
-
-          raise Core::ValidationError, "#{field} must be one of: #{Array(allowed).join(", ")}#{qualifier}"
-        end
-      end
-
-      # A `when` entry is either `{present: true|false}` or a scalar the
-      # supplied value must equal. Rules never resolve declared defaults.
-      def rule_condition_met?(params, field, condition)
-        if condition.is_a?(Hash) && (condition.key?("present") || condition.key?(:present))
-          expected = condition["present"].nil? ? condition[:present] : condition["present"]
-          return field_present?(params, field) == (expected == true)
-        end
-        return false unless param_key?(params, field)
-
-        param_value(params, field).to_s == condition.to_s
-      end
-
-      def rule_condition_label(field, condition)
-        if condition.is_a?(Hash) && (condition.key?("present") || condition.key?(:present))
-          expected = condition["present"].nil? ? condition[:present] : condition["present"]
-          return (expected == true) ? "#{field} is present" : "#{field} is absent"
-        end
-
-        "#{field} is #{condition}"
-      end
-
-      def field_present?(params, field)
-        return false unless param_key?(params, field)
-
-        value = param_value(params, field)
-        case value
-        when false then true
-        when Array then value.any? { |item| present_value?(item) }
-        else present_value?(value)
-        end
-      end
-
-      def param_key?(params, field)
-        params.key?(field.to_sym) || params.key?(field.to_s)
-      end
-
-      # Indifferent value lookup for a string-or-symbol field across params that
-      # may be keyed either way.
-      def param_value(params, field)
-        if params.key?(field.to_sym)
-          params[field.to_sym]
-        elsif params.key?(field.to_s)
-          params[field.to_s]
-        end
-      end
-
-      def present_value?(value)
-        case value
-        when nil, false then false
-        when true then true
-        when String then !value.strip.empty?
-        when Array, Hash then !value.empty?
-        else true
-        end
-      end
-
       def default_response_class
         if self.class.const_defined?(:RESPONSE_CLASS, false)
           self.class::RESPONSE_CLASS

data/lib/runapi/core/version.rb

@@ -2,7 +2,7 @@
 
 module RunApi
   module Core
-    VERSION = "0.5.2"
+    VERSION = "0.6.0"
   end
 
   VERSION = Core::VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: runapi-core
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - RunAPI