ledger_sync 1.3.5 → 1.4.0

data/lib/ledger_sync/ledger_configuration_store.rb

@@ -0,0 +1,56 @@
+module LedgerSync
+  class LedgerConfigurationStore
+    include Enumerable
+
+    attr_reader :configs, :inflections
+
+    def initialize
+      @keys = []
+      @configs = {}
+      @inflections = []
+      @class_configs = {}
+    end
+
+    def add_alias(client_key, existing_config)
+      if respond_to?(client_key)
+        raise LedgerSync::ConfigurationError, "Alias already taken: #{client_key}" if send(client_key) != existing_config
+
+        return
+      end
+
+      _instance_methods_for(client_key: client_key, ledger_config: existing_config)
+    end
+
+    def config_from_class(client_class:)
+      @class_configs.fetch(client_class)
+    end
+
+    def each
+      configs.each { |k, v| yield(k, v) }
+    end
+
+    def register_ledger(ledger_config:)
+      _instance_methods_for(
+        client_key: ledger_config.root_key,
+        ledger_config: ledger_config
+      )
+    end
+
+    private
+
+    def _instance_methods_for(client_key:, ledger_config:)
+      @keys << client_key.to_sym
+
+      @configs[client_key] = ledger_config
+      @class_configs[ledger_config.client_class] = ledger_config
+
+      instance_variable_set(
+        "@#{client_key}",
+        ledger_config
+      )
+
+      @inflections |= [ledger_config.module_string]
+      self.class.class_eval { attr_reader client_key }
+    end
+  end
+end

data/lib/ledger_sync/ledgers/client.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    class Client
+      include Fingerprintable::Mixin
+      include SimplySerializable::Mixin
+      include Validatable
+      include Util::Mixins::ResourceRegisterableMixin
+
+      simply_serialize only: %i[
+        ledger_configuration
+      ]
+
+      def initialize(*)
+        raise NotImplementedError
+      end
+
+      def ledger_configuration
+        self.class.config
+      end
+
+      def base_module
+        self.class.base_module
+      end
+
+      def ledger_attributes_to_save
+        return {} if self.class.ledger_attributes_to_save.nil?
+
+        Hash[self.class.ledger_attributes_to_save.map do |attribute|
+          [attribute, send(attribute)]
+        end]
+      end
+
+      def operation_for(args = {})
+        method = args.fetch(:method)
+        resource = args.fetch(:resource)
+
+        self.class.operation_class_for(
+          method: method,
+          resource_class: resource.class
+        ).new(
+          client: self,
+          resource: resource
+        )
+      end
+
+      def searcher_for(resource_type:, query: '')
+        searcher_class_for(resource_type: resource_type).new(client: self, query: query)
+      end
+
+      def searcher_class_for(resource_type:)
+        base_module.const_get(LedgerSync::Util::StringHelpers.camelcase(resource_type.to_s))::Searcher
+      end
+
+      def url_for(*_args)
+        raise NotImplementedError
+      end
+
+      def parse_operation_error(*)
+        nil
+      end
+
+      def self.base_module
+        config.base_module
+      end
+
+      def self.base_operation_module_for(resource_class:)
+        base_module.const_get("#{resource_class.resource_module_str}::Operations")
+      end
+
+      def self.config
+        @config ||= LedgerSync.ledgers.config_from_class(client_class: self)
+      end
+
+      # These are attributes that must always be saved after the client is called.
+      # For example, the library will handle refreshing tokens that will need
+      # to be saved back to the application layer for future use.
+      def self.ledger_attributes_to_save
+        raise NotImplementedError
+      end
+
+      def self.ledger_resource_type_for(resource_class:)
+        ledger_resource_type_overrides[resource_class] || resource_class.resource_type.to_s
+      end
+
+      def self.ledger_resource_type_overrides
+        {}
+      end
+
+      def self.operation_class_for(method:, resource_class:)
+        base_operation_module_for(resource_class: resource_class)
+          .const_get(LedgerSync::Util::StringHelpers.camelcase(method.to_s))
+      end
+
+      def self.resource_from_ledger_type(type:, converter: nil)
+        converter ||= proc { |n| n.underscore }
+        ledger_resource_type_overrides.invert[converter.call(type).to_sym] || resources[converter.call(type).to_sym]
+      end
+
+      def self.resources
+        @resources ||= {}
+      end
+
+      def self.root_key
+        @root_key ||= config.root_key
+      end
+
+      def self.url_for(resource: nil); end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/contract.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    class Contract < Dry::Validation::Contract
+      module Types
+        include Dry::Types()
+
+        Reference = Dry::Schema.Params do
+          required(:object).filled(eql?: :reference)
+          required(:id).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/dashboard_url_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    class DashboardURLHelper
+      attr_reader :resource,
+                  :base_url
+
+      def initialize(args = {})
+        @resource = args.fetch(:resource)
+        @base_url = args.fetch(:base_url)
+      end
+
+      def url
+        File.join(base_url, resource_path)
+      end
+
+      def resource_path
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/infer_client_mixin.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module InferClientMixin
+        module ClassMethods
+          def inferred_client_class
+            @inferred_client_class ||= begin
+              return if name.nil?
+
+              parts = name.split('::')
+              return unless parts.include?('Ledgers')
+
+              LedgerSync::Ledgers.const_get(
+                parts[parts.index('Ledgers') + 1]
+              )::Client
+            end
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/infer_resource_class_mixin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'infer_client_mixin'
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module InferResourceClassMixin
+        module ClassMethods
+          def inferred_resource_class
+            @inferred_resource_class ||= begin
+              parts = name.split('::')
+              inferred_client_class.base_module.const_get(parts[parts.index('Ledgers') + 2])
+            end
+          end
+        end
+
+        def self.included(base)
+          base.include InferClientMixin
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/infer_serializer_mixin.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'infer_client_mixin'
+require_relative 'infer_resource_class_mixin'
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module InferSerializerMixin
+        module ClassMethods
+          def inferred_deserializer_class
+            @inferred_deserializer_class ||= inferred_client_class.base_module.const_get(
+              inferred_deserializer_class_name
+            )
+          end
+
+          def inferred_deserializer_class_name
+            @inferred_deserializer_class_name ||= "#{inferred_resource_class.resource_module_str}::Deserializer"
+          end
+
+          def inferred_searcher_deserializer_class
+            @inferred_searcher_deserializer_class ||= inferred_client_class.base_module.const_get(
+              inferred_searcher_deserializer_class_name
+            )
+          end
+
+          def inferred_searcher_deserializer_class_name
+            @inferred_searcher_deserializer_class_name ||= "#{inferred_resource_class.resource_module_str}::SearcherDeserializer"
+          end
+
+          def inferred_serializer_class
+            @inferred_serializer_class ||= begin
+              inferred_client_class.base_module.const_get(
+                inferred_serializer_class_name
+              )
+            end
+          end
+
+          def inferred_serializer_class_name
+            @inferred_serializer_class_name ||= "#{inferred_resource_class.resource_module_str}::Serializer"
+          end
+        end
+
+        def self.included(base)
+          base.include InferClientMixin
+          base.include InferResourceClassMixin
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/infer_validation_contract_mixin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module InferValidationContractMixin
+        module ClassMethods
+          def inferred_validation_contract_class
+            @inferred_validation_contract_class ||= begin
+              const_get(
+                inferred_validation_contract_class_name
+              )
+            end
+          end
+
+          def inferred_validation_contract_class_name
+            @inferred_validation_contract_class_name ||= "#{name}::Contract"
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/offset_and_limit_pagination_searcher_mixin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module OffsetAndLimitPaginationSearcherMixin
+        def next_searcher
+          paginate(limit: limit, offset: offset + limit)
+        end
+
+        def previous_searcher
+          return nil if offset <= 1
+
+          paginate(limit: limit, offset: offset - limit)
+        end
+
+        private
+
+        def default_offset
+          raise NotImplementedError
+        end
+
+        def default_limit
+          10
+        end
+
+        def limit
+          pagination.fetch(:limit, default_limit).to_i
+        end
+
+        def offset
+          pagination.fetch(:offset, default_offset).to_i
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/mixins/serialization_mixin.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module Mixins
+      module SerializationMixin
+        module ClassMethods
+          def inferred_deserializer_class
+            @inferred_deserializer_class ||= inferred_serialization_class(type: 'Deserializer')
+          end
+
+          def inferred_serialization_class(args = {})
+            type = args.fetch(:type)
+
+            inferred_client_class.base_module.const_get(
+              "#{inferred_resource_class.resource_module_str}::#{type.camelcase}"
+            )
+          end
+
+          def inferred_serializer_class
+            @inferred_serializer_class ||= inferred_serialization_class(type: 'Serializer')
+          end
+        end
+
+        def self.included(base)
+          base.include InferClientMixin
+          base.include InferResourceClassMixin
+          base.extend ClassMethods
+        end
+
+        def deserializer
+          self.class.inferred_deserializer_class.new
+        end
+
+        def serializer
+          self.class.inferred_serializer_class.new
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/ledgers/netsuite/account/deserializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Ledgers
+    module NetSuite
+      class Account
+        class Deserializer < NetSuite::Deserializer
+          id
+
+          attribute :name,
+                    hash_attribute: :acctname
+
+          mapping :account_type,
+                  hash_attribute: :accttype,
+                  hash: Account::TYPES.invert
+
+          attribute :number,
+                    hash_attribute: :acctnumber
+        end
+      end
+    end
+  end
+end