fmrest 0.10.0 → 0.13.0

data/lib/fmrest/spyke/relation.rb

@@ -1,359 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    class Relation < ::Spyke::Relation
-      SORT_PARAM_MATCHER = /(.*?)(!|__desc(?:end)?)?\Z/.freeze
-
-      # NOTE: We need to keep limit, offset, sort, query and portal accessors
-      # separate from regular params because FM Data API uses either "limit" or
-      # "_limit" (or "_offset", etc.) as param keys depending on the type of
-      # request, so we can't set the params until the last moment
-
-
-      attr_accessor :limit_value, :offset_value, :sort_params, :query_params,
-                    :included_portals, :portal_params, :script_params
-
-      def initialize(*_args)
-        super
-
-        @limit_value = klass.default_limit
-
-        if klass.default_sort.present?
-          @sort_params = Array.wrap(klass.default_sort).map { |s| normalize_sort_param(s) }
-        end
-
-        @query_params = []
-
-        @included_portals = nil
-        @portal_params = {}
-        @script_params = {}
-      end
-
-      # @param options [String, Array, Hash, nil, false] sets script params to
-      #   execute in the next get or find request
-      #
-      # @example
-      #   # Find records and run the script named "My script"
-      #   Person.script("My script").find_some
-      #
-      #   # Find records and run the script named "My script" with param "the param"
-      #   Person.script(["My script", "the param"]).find_some
-      #
-      #   # Find records and run a prerequest, presort and after (normal) script
-      #   Person.script(after: "Script", prerequest: "Prereq script", presort: "Presort script").find_some
-      #
-      #   # Same as above, but passing parameters too
-      #   Person.script(
-      #     after:      ["After script", "the param"],
-      #     prerequest: ["Prereq script", "the param"],
-      #     presort: o  ["Presort script", "the param"]
-      #   ).find_some
-      #
-      #   Person.script(nil).find_some # Disable script execution
-      #   Person.script(false).find_some # Disable script execution
-      #
-      # @return [FmRest::Spyke::Relation] a new relation with the script
-      #   options applied
-      def script(options)
-        with_clone do |r|
-          if options.eql?(false) || options.eql?(nil)
-            r.script_params = {}
-          else
-            r.script_params = script_params.merge(FmRest::V1.convert_script_params(options))
-          end
-        end
-      end
-
-      # @param value_or_hash [Integer, Hash] the limit value for this layout,
-      #   or a hash with limits for the layout's portals
-      # @example
-      #   Person.limit(10) # Set layout limit
-      #   Person.limit(children: 10) # Set portal limit
-      # @return [FmRest::Spyke::Relation] a new relation with the limits
-      #   applied
-      def limit(value_or_hash)
-        with_clone do |r|
-          if value_or_hash.respond_to?(:each)
-            r.set_portal_params(value_or_hash, :limit)
-          else
-            r.limit_value = value_or_hash
-          end
-        end
-      end
-
-      # @param value_or_hash [Integer, Hash] the offset value for this layout,
-      #   or a hash with offsets for the layout's portals
-      # @example
-      #   Person.offset(10) # Set layout offset
-      #   Person.offset(children: 10) # Set portal offset
-      # @return [FmRest::Spyke::Relation] a new relation with the offsets
-      #   applied
-      def offset(value_or_hash)
-        with_clone do |r|
-          if value_or_hash.respond_to?(:each)
-            r.set_portal_params(value_or_hash, :offset)
-          else
-            r.offset_value = value_or_hash
-          end
-        end
-      end
-
-      # Allows sort params given in either hash format (using FM Data API's
-      # format), or as a symbol, in which case the of the attribute must match
-      # a known mapped attribute, optionally suffixed with `!` or `__desc` to
-      # signify it should use descending order.
-      #
-      # @param args [Array<Symbol, Hash>] the names of attributes to sort by with
-      #   optional `!` or `__desc` suffix, or a hash of options as expected by
-      #   the FM Data API
-      # @example
-      #   Person.sort(:first_name, :age!)
-      #   Person.sort(:first_name, :age__desc)
-      #   Person.sort(:first_name, :age__descend)
-      #   Person.sort({ fieldName: "FirstName" }, { fieldName: "Age", sortOrder: "descend" })
-      # @return [FmRest::Spyke::Relation] a new relation with the sort options
-      #   applied
-      def sort(*args)
-        with_clone do |r|
-          r.sort_params = args.flatten.map { |s| normalize_sort_param(s) }
-        end
-      end
-      alias order sort
-
-      # Sets the portals to include with each record in the response.
-      #
-      # @param args [Array<Symbol, String>, true, false] the names of portals to
-      #   include, or `false` to request no portals
-      # @example
-      #   Person.portal(:relatives, :pets)
-      #   Person.portal(false) # Disables portals
-      #   Person.portal(true) # Enables portals (includes all)
-      # @return [FmRest::Spyke::Relation] a new relation with the portal
-      #   options applied
-      def portal(*args)
-        raise ArgumentError, "Call `portal' with at least one argument" if args.empty?
-
-        with_clone do |r|
-          if args.length == 1 && args.first.eql?(true) || args.first.eql?(false)
-            r.included_portals = args.first ? nil : []
-          else
-            r.included_portals ||= []
-            r.included_portals += args.flatten.map { |p| normalize_portal_param(p) }
-            r.included_portals.uniq!
-          end
-        end
-      end
-      alias includes portal
-      alias portals portal
-
-      # Same as calling `portal(true)`
-      #
-      # @return (see #portal)
-      def with_all_portals
-        portal(true)
-      end
-
-      # Same as calling `portal(false)`
-      #
-      # @return (see #portal)
-      def without_portals
-        portal(false)
-      end
-
-      def query(*params)
-        with_clone do |r|
-          r.query_params += params.flatten.map { |p| normalize_query_params(p) }
-        end
-      end
-
-      def omit(params)
-        query(params.merge(omit: true))
-      end
-
-      # @return [Boolean] whether a query was set on this relation
-      def has_query?
-        query_params.present?
-      end
-
-      # Finds a single instance of the model by forcing limit = 1, or simply
-      # fetching the record by id if the primary key was set
-      #
-      # @return [FmRest::Spyke::Base]
-      def find_one
-        @find_one ||=
-          if primary_key_set?
-            without_collection_params { super }
-          else
-            klass.new_collection_from_result(limit(1).fetch).first
-          end
-      rescue ::Spyke::ConnectionError => error
-        fallback_or_reraise(error, default: nil)
-      end
-      alias_method :first, :find_one
-      alias_method :any, :find_one
-
-      # Yields each batch of records that was found by the find options.
-      #
-      # NOTE: By its nature, batch processing is subject to race conditions if
-      # other processes are modifying the database
-      #
-      # @param batch_size [Integer] Specifies the size of the batch.
-      # @return [Enumerator] if called without a block.
-      def find_in_batches(batch_size: 1000)
-        unless block_given?
-          return to_enum(:find_in_batches, batch_size: batch_size) do
-            total = limit(1).find_some.metadata.data_info.found_count
-            (total - 1).div(batch_size) + 1
-          end
-        end
-
-        offset = 1 # DAPI offset is 1-based
-
-        loop do
-          relation = offset(offset).limit(batch_size)
-
-          records = relation.find_some
-
-          yield records if records.length > 0
-
-          break if records.length < batch_size
-
-          # Save one iteration if the total is a multiple of batch_size
-          if found_count = records.metadata.data_info && records.metadata.data_info.found_count
-            break if found_count == (offset - 1) + batch_size
-          end
-
-          offset += batch_size
-        end
-      end
-
-      # Looping through a collection of records from the database (using the
-      # #all method, for example) is very inefficient since it will fetch and
-      # instantiate all the objects at once.
-      #
-      # In that case, batch processing methods allow you to work with the
-      # records in batches, thereby greatly reducing memory consumption and be
-      # lighter on the Data API server.
-      #
-      # The find_each method uses #find_in_batches with a batch size of 1000
-      # (or as specified by the :batch_size option).
-      #
-      # NOTE: By its nature, batch processing is subject to race conditions if
-      # other processes are modifying the database
-      #
-      # @param (see #find_in_batches)
-      # @example
-      #   Person.find_each do |person|
-      #     person.greet
-      #   end
-      #
-      #   Person.query(name: "==Mitch").find_each do |person|
-      #     person.say_hi
-      #   end
-      # @return (see #find_in_batches)
-      def find_each(batch_size: 1000)
-        unless block_given?
-          return to_enum(:find_each, batch_size: batch_size) do
-            limit(1).find_some.metadata.data_info.found_count
-          end
-        end
-
-        find_in_batches(batch_size: batch_size) do |records|
-          records.each { |r| yield r }
-        end
-      end
-
-      protected
-
-      def set_portal_params(params_hash, param)
-        # Copy portal_params so we're not modifying the same hash as the parent
-        # scope
-        self.portal_params = portal_params.dup
-
-        params_hash.each do |portal_name, value|
-          # TODO: Use a hash like { portal_name: { param: value } } instead so
-          # we can intelligently avoid including portal params for excluded
-          # portals
-          key = "#{param}.#{normalize_portal_param(portal_name)}"
-
-          # Delete key if value is falsy
-          if !value && portal_params.has_key?(key)
-            portal_params.delete(key)
-          else
-            self.portal_params[key] = value
-          end
-        end
-      end
-
-      private
-
-      def normalize_sort_param(param)
-        if param.kind_of?(Symbol) || param.kind_of?(String)
-          _, attr, descend = param.to_s.match(SORT_PARAM_MATCHER).to_a
-
-          unless field_name = klass.mapped_attributes[attr]
-            raise ArgumentError, "Unknown attribute `#{attr}' given to sort as #{param.inspect}. If you want to use a custom sort pass a hash in the Data API format"
-          end
-
-          hash = { fieldName: field_name }
-          hash[:sortOrder] = "descend" if descend
-          return hash
-        end
-
-        # TODO: Sanitize sort hash param for FM Data API conformity?
-        param
-      end
-
-      def normalize_portal_param(param)
-        if param.kind_of?(Symbol)
-          portal_key, = klass.portal_options.find { |_, opts| opts[:name].to_s == param.to_s }
-
-          unless portal_key
-            raise ArgumentError, "Unknown portal #{param.inspect}. If you want to include a portal not defined in the model pass it as a string instead"
-          end
-
-          return portal_key
-        end
-
-        param
-      end
-
-      def normalize_query_params(params)
-        params.each_with_object({}) do |(k, v), normalized|
-          if k == :omit || k == "omit"
-            # FM Data API wants omit values as strings, e.g. "true" or "false"
-            # rather than true/false
-            normalized["omit"] = v.to_s
-            next
-          end
-
-          # TODO: Raise ArgumentError if an attribute given as symbol isn't defiend
-          if k.kind_of?(Symbol) && klass.mapped_attributes.has_key?(k)
-            normalized[klass.mapped_attributes[k].to_s] = v
-          else
-            normalized[k.to_s] = v
-          end
-        end
-      end
-
-      def primary_key_set?
-        params[klass.primary_key].present?
-      end
-
-      def without_collection_params
-        orig_values = limit_value, offset_value, sort_params, query_params
-        self.limit_value = self.offset_value = self.sort_params = self.query_params = nil
-        yield
-      ensure
-        self.limit_value, self.offset_value, self.sort_params, self.query_params = orig_values
-      end
-
-      def with_clone
-        clone.tap do |relation|
-          yield relation
-        end
-      end
-    end
-  end
-end

data/lib/fmrest/spyke/spyke_formatter.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "ostruct"
-
-module FmRest
-  module Spyke
-    # Metadata class to be passed to Spyke::Collection#metadata
-    class Metadata < Struct.new(:messages, :script, :data_info)
-      alias_method :scripts, :script
-    end
-
-    class DataInfo < OpenStruct
-      def total_record_count; totalRecordCount; end
-      def found_count; foundCount; end
-      def returned_count; returnedCount; end
-    end
-
-    # Response Faraday middleware for converting FM API's response JSON into
-    # Spyke's expected format
-    class SpykeFormatter < ::Faraday::Response::Middleware
-      SINGLE_RECORD_RE = %r(/records/\d+\z).freeze
-      MULTIPLE_RECORDS_RE = %r(/records\z).freeze
-      CONTAINER_RE = %r(/records/\d+/containers/[^/]+/\d+\z).freeze
-      FIND_RECORDS_RE = %r(/_find\b).freeze
-      SCRIPT_REQUEST_RE = %r(/script/[^/]+\z).freeze
-
-      VALIDATION_ERROR_RANGE = 500..599
-
-      # @param app [#call]
-      # @param model [Class<FmRest::Spyke::Base>]
-      def initialize(app, model)
-        super(app)
-        @model = model
-      end
-
-      # @param env [Faraday::Env]
-      def on_complete(env)
-        return unless env.body.is_a?(Hash)
-
-        json = env.body
-
-        case
-        when single_record_request?(env)
-          env.body = prepare_single_record(json)
-        when multiple_records_request?(env), find_request?(env)
-          env.body = prepare_collection(json)
-        when create_request?(env), update_request?(env), delete_request?(env), container_upload_request?(env)
-          env.body = prepare_save_response(json)
-        when execute_script_request?(env)
-          env.body = build_base_hash(json)
-        else
-          # Attempt to parse unknown requests too
-          env.body = build_base_hash(json)
-        end
-      end
-
-      private
-
-      # @param json [Hash]
-      # @return [Hash] the response in Spyke format
-      def prepare_save_response(json)
-        response = json[:response]
-
-        data = {}
-        data[:mod_id] = response[:modId] if response[:modId]
-        data[:id]     = response[:recordId].to_i if response[:recordId]
-
-        build_base_hash(json, true).merge!(data: data)
-      end
-
-      # (see #prepare_save_response)
-      def prepare_single_record(json)
-        data =
-          json[:response][:data] &&
-          prepare_record_data(json[:response][:data].first)
-
-        build_base_hash(json).merge!(data: data)
-      end
-
-      # (see #prepare_save_response)
-      def prepare_collection(json)
-        data =
-          json[:response][:data] &&
-          json[:response][:data].map { |record_data| prepare_record_data(record_data) }
-
-        build_base_hash(json).merge!(data: data)
-      end
-
-      # @param json [Hash]
-      # @param include_errors [Boolean]
-      # @return [FmRest::Spyke::Metadata] the skeleton structure for a
-      #   Spyke-formatted response
-      def build_base_hash(json, include_errors = false)
-        {
-          metadata: Metadata.new(
-            prepare_messages(json),
-            prepare_script_results(json),
-            prepare_data_info(json)
-          ).freeze,
-          errors: include_errors ? prepare_errors(json) : {}
-        }
-      end
-
-      # @param json [Hash]
-      # @return [Array<OpenStruct>] the skeleton structure for a
-      #   Spyke-formatted response
-      def prepare_messages(json)
-        return [] unless json[:messages]
-        json[:messages].map { |m| OpenStruct.new(m).freeze }.freeze
-      end
-
-      # @param json [Hash]
-      # @return [OpenStruct] the script(s) execution results for Spyke metadata
-      #   format
-      def prepare_script_results(json)
-        results = {}
-
-        [:prerequest, :presort].each do |s|
-          if json[:response][:"scriptError.#{s}"]
-            results[s] = OpenStruct.new(
-              result: json[:response][:"scriptResult.#{s}"],
-              error:  json[:response][:"scriptError.#{s}"]
-            ).freeze
-          end
-        end
-
-        if json[:response][:scriptError]
-          results[:after] = OpenStruct.new(
-            result: json[:response][:scriptResult],
-            error:  json[:response][:scriptError]
-          ).freeze
-        end
-
-        results.present? ? OpenStruct.new(results).freeze : nil
-      end
-
-      # @param json [Hash]
-      # @return [OpenStruct] the script(s) execution results for
-      #   Spyke metadata format
-      def prepare_data_info(json)
-        data_info = json[:response] && json[:response][:dataInfo]
-
-        return nil unless data_info.present?
-
-        DataInfo.new(data_info).freeze
-      end
-
-      # @param json [Hash]
-      # @return [Hash] the errors hash in Spyke format
-      def prepare_errors(json)
-        # Code 0 means "No Error"
-        # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
-        return {} if json[:messages][0][:code].to_i == 0
-
-        json[:messages].each_with_object(base: []) do |message, hash|
-          # Only include validation errors
-          next unless VALIDATION_ERROR_RANGE.include?(message[:code].to_i)
-
-          hash[:base] << "#{message[:message]} (#{message[:code]})"
-        end
-      end
-
-      # `json_data` is expected in this format:
-      #
-      #     {
-      #       "fieldData": {
-      #         "fieldName1" : "fieldValue1",
-      #         "fieldName2" : "fieldValue2",
-      #         ...
-      #       },
-      #       "portalData": {
-      #         "portal1" : [
-      #           { <portalRecord1> },
-      #           { <portalRecord2> },
-      #           ...
-      #         ],
-      #         "portal2" : [
-      #           { <portalRecord1> },
-      #           { <portalRecord2> },
-      #           ...
-      #         ]
-      #       },
-      #       "modId": <Id_for_last_modification>,
-      #       "recordId": <Unique_internal_ID_for_this_record>
-      #     }
-      #
-      # @param json_data [Hash]
-      # @return [Hash] the record data in Spyke format
-      def prepare_record_data(json_data)
-        out = { id: json_data[:recordId].to_i, mod_id: json_data[:modId] }
-        out.merge!(json_data[:fieldData])
-        out.merge!(prepare_portal_data(json_data[:portalData])) if json_data[:portalData]
-        out
-      end
-
-      # Extracts `recordId` and strips the `"PortalName::"` field prefix for each
-      # portal
-      #
-      # Sample `json_portal_data`:
-      #
-      #     "portalData": {
-      #       "Orders":[
-      #         { "Orders::DeliveryDate": "3/7/2017", "recordId": "23" }
-      #       ]
-      #     }
-      #
-      # @param json_portal_data [Hash]
-      # @return [Hash] the portal data in Spyke format
-      def prepare_portal_data(json_portal_data)
-        json_portal_data.each_with_object({}) do |(portal_name, portal_records), out|
-          portal_options = @model.portal_options[portal_name.to_s] || {}
-
-          out[portal_name] =
-            portal_records.map do |portal_fields|
-              attributes = { id: portal_fields[:recordId].to_i }
-              attributes[:mod_id] = portal_fields[:modId] if portal_fields[:modId]
-
-              prefix = portal_options[:attribute_prefix] || portal_name
-              prefix_matcher = /\A#{prefix}::/
-
-              portal_fields.each do |k, v|
-                next if :recordId == k || :modId == k
-                attributes[k.to_s.gsub(prefix_matcher, "").to_sym] = v
-              end
-
-              attributes
-            end
-        end
-      end
-
-      # @param env [Faraday::Env]
-      # @return [Boolean]
-      def single_record_request?(env)
-        env.method == :get && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      # (see #single_record_request?)
-      def multiple_records_request?(env)
-        env.method == :get && env.url.path.match(MULTIPLE_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def find_request?(env)
-        env.method == :post && env.url.path.match(FIND_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def update_request?(env)
-        env.method == :patch && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      # (see #single_record_request?)
-      def create_request?(env)
-        env.method == :post && env.url.path.match(MULTIPLE_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def container_upload_request?(env)
-        env.method == :post && env.url.path.match(CONTAINER_RE)
-      end
-
-      # (see #single_record_request?)
-      def delete_request?(env)
-        env.method == :delete && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      def execute_script_request?(env)
-        env.method == :get && env.url.path.match(SCRIPT_REQUEST_RE)
-      end
-    end
-  end
-end