ledger_sync 1.3.3 → 1.4.2

data/lib/ledger_sync/{adaptor_configuration.rb → ledger_configuration.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  class AdaptorConfiguration
+  class LedgerConfiguration
     include Fingerprintable::Mixin
     include SimplySerializable::Mixin
 
@@ -13,7 +13,7 @@ module LedgerSync
     attr_reader :aliases,
                 :root_key
 
-    serialize only: %i[
+    simply_serialize only: %i[
       aliases
       module_string
       root_key
@@ -27,31 +27,31 @@ module LedgerSync
       @module_string = module_string || LedgerSync::Util::StringHelpers.camelcase(root_key)
     end
 
-    def adaptor_klass
-      @adaptor_klass ||= base_module::Adaptor
+    def client_class
+      @client_class ||= base_module::Client
     end
 
     def add_alias(new_alias)
       @aliases << new_alias
-      LedgerSync.adaptors.add_alias(new_alias, self)
+      LedgerSync.ledgers.add_alias(new_alias, self)
     end
 
     def base_module
       @base_module ||= begin
-        LedgerSync::Adaptors.const_get(@module_string)
+        LedgerSync::Ledgers.const_get(@module_string)
       end
     end
 
-    # Delegate #new to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new(...)
+    # Delegate #new to the client class enabling faster client initialization
+    # e.g. LedgerSync.ledgers.test.new(...)
     def new(*args)
-      adaptor_klass.new(*args)
+      client_class.new(*args)
     end
 
-    # Delegate #new_from_env to the adaptor class enabling faster adaptor initialization
-    # e.g. LedgerSync.adaptors.test.new_from_env(...)
+    # Delegate #new_from_env to the client class enabling faster client initialization
+    # e.g. LedgerSync.ledgers.test.new_from_env(...)
     def new_from_env(*args)
-      adaptor_klass.new_from_env(*args)
+      client_class.new_from_env(*args)
     end
 
     def test?

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/{adaptors → ledgers}/contract.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  module Adaptors
+  module Ledgers
     class Contract < Dry::Validation::Contract
       module Types
         include Dry::Types()

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/{adaptors → ledgers}/mixins/infer_resource_class_mixin.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
+require_relative 'infer_client_mixin'
+
 module LedgerSync
-  module Adaptors
+  module Ledgers
     module Mixins
       module InferResourceClassMixin
         module ClassMethods
           def inferred_resource_class
             @inferred_resource_class ||= begin
               parts = name.split('::')
-              LedgerSync.const_get(parts[parts.index('Adaptors') + 2])
+              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

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/{adaptors → ledgers}/mixins/infer_validation_contract_mixin.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  module Adaptors
+  module Ledgers
     module Mixins
       module InferValidationContractMixin
         module ClassMethods

data/lib/ledger_sync/{adaptors → ledgers}/mixins/offset_and_limit_pagination_searcher_mixin.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LedgerSync
-  module Adaptors
+  module Ledgers
     module Mixins
       module OffsetAndLimitPaginationSearcherMixin
         def next_searcher

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