ledger_sync 0.1.0 → 1.0.0

data/lib/ledger_sync/adaptors/test/payment/operations/upsert.rb

@@ -0,0 +1,53 @@
+module LedgerSync
+  module Adaptors
+    module Test
+      module Payment
+        module Operations
+          class Upsert < Operation::Upsert
+            class Contract < LedgerSync::Adaptors::Contract
+              schema do
+                required(:ledger_id).maybe(:string)
+                required(:amount).value(:integer)
+                required(:currency).value(:string)
+                required(:customer).value(Types::Reference)
+              end
+            end
+
+            private
+
+            def build
+              op =  if qbo_payment?
+                      Update.new(adaptor: adaptor, resource: resource)
+                    else
+                      Create.new(adaptor: adaptor, resource: resource)
+                    end
+
+              build_customer_operation
+              add_root_operation(op)
+            end
+
+            def build_customer_operation
+              customer = Customer::Operations::Upsert.new(
+                adaptor: adaptor,
+                resource: resource.customer
+              )
+
+              add_before_operation(customer)
+            end
+
+            def find_result
+              @find_result ||= Find.new(
+                adaptor: adaptor,
+                resource: resource
+              ).perform
+            end
+
+            def qbo_payment?
+              find_result.success?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/concerns/validatable.rb

@@ -0,0 +1,19 @@
+module LedgerSync
+  module Validatable
+    def valid?
+      validate.success?
+    end
+
+    def validate
+      raise NotImplementedError
+    end
+
+    def validate_or_fail
+      if valid?
+        Resonad.Success(self)
+      else
+        Resonad.Failure
+      end
+    end
+  end
+end

data/lib/ledger_sync/core_ext/resonad.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'ledger_sync/util/debug'
+require 'simply_serializable'
+
+class Resonad
+  include SimplySerializable::Mixin
+
+  class Success < Resonad
+    serialize only: %i[value]
+  end
+
+  class Failure < Resonad
+    serialize only: %i[error]
+  end
+end

data/lib/ledger_sync/error.rb

@@ -0,0 +1,10 @@
+module LedgerSync
+  class Error < StandardError
+    attr_reader :message
+
+    def initialize(message:)
+      @message = message
+      super(message)
+    end
+  end
+end

data/lib/ledger_sync/error/adaptor_errors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class Error
+    class AdaptorError < Error
+      attr_reader :adaptor
+
+      def initialize(adaptor:, message:)
+        @adaptor = adaptor
+        super(message: message)
+      end
+
+      class MissingAdaptorError < self
+        def initialize(message:)
+          super(message: message, adaptor: nil)
+        end
+      end
+
+      class AdaptorValidationError < self
+        attr_reader :attribute, :validation
+
+        def initialize(message:, adaptor:, attribute:, validation:)
+          @attribute = attribute
+          @validation = validation
+          super(message: message, adaptor: adaptor)
+        end
+      end
+
+      class ThrottleError < self
+        attr_reader :rate_limiting_wait_in_seconds
+
+        def initialize(adaptor:, message: nil)
+          message ||= 'Your request has been throttled.'
+          @rate_limiting_wait_in_seconds = LedgerSync.adaptors.config_from_klass(
+            klass: adaptor.class
+          ).rate_limiting_wait_in_seconds
+
+          super(adaptor: adaptor, message: message)
+        end
+      end
+
+      class AuthenticationError < self; end
+      class AuthorizationError < self; end
+      class ConfigurationError < self; end
+    end
+  end
+end

data/lib/ledger_sync/error/operation_errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class Error
+    class OperationError < Error
+      attr_reader :operation
+
+      def initialize(message:, operation:)
+        @operation = operation
+        super(message: message)
+      end
+
+      class DuplicateLedgerResourceError < self; end
+      class NotFoundError < self; end
+      class LedgerValidationError < self; end
+
+      class PerformedOperationError < self
+        def initialize(message: nil, operation:)
+          message ||= 'Operation has already been performed. Please check the result.'
+
+          super(message: message, operation: operation)
+        end
+      end
+
+      class ValidationError < self
+        attr_reader :attribute,
+                    :validation
+
+        def initialize(message:, attribute:, operation:, validation:)
+          @attribute = attribute
+          @validation = validation
+
+          super(
+            message: message,
+            operation: operation
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/error/resource_errors.rb

@@ -0,0 +1,20 @@
+module LedgerSync
+  class ResourceError < Error
+    attr_reader :resource
+
+    def initialize(message:, resource:)
+      @resource = resource
+      super(message: message)
+    end
+
+    class MissingResourceError < self
+      attr_reader :resource_type, :resource_external_id
+
+      def initialize(message:, resource_type:, resource_external_id:)
+        @resource_type = resource_type
+        @resource_external_id = resource_external_id
+        super(message: message, resource: nil)
+      end
+    end
+  end
+end

data/lib/ledger_sync/resource.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Template class for named resources such as
+# LedgerSync::Invoice, LedgerSync::Contact, etc.
+module LedgerSync
+  class Resource
+    include SimplySerializable::Mixin
+    include Validatable
+    include Fingerprintable::Mixin
+
+    # serialize only: %i[
+    #   attributes
+    #   external_id
+    #   ledger_id
+    #   sync_token
+    # ]
+
+    attr_accessor :external_id, :ledger_id, :sync_token
+
+    def initialize(external_id: nil, ledger_id: nil, sync_token: nil, **data)
+      @external_id = external_id.to_s.to_sym
+      @ledger_id = ledger_id
+      @sync_token = sync_token
+
+      data.each do |attr_key, val|
+        if (self.class.references || {}).key?(attr_key)
+          raise "#{val} must be of type #{self.class.references[attr_key]}" if self.class.references[attr_key] != val.class
+        end
+
+        raise "#{attr_key} is not an attribute of #{self.class}" unless self.class.attributes.include?(attr_key)
+      end
+
+      self.class.attributes.each do |attribute|
+        instance_variable_set("@#{attribute}", data.dig(attribute))
+      end
+    end
+
+    def attributes
+      self.class.attributes
+    end
+
+    def references
+      self.class.references
+    end
+
+    def serialize_attributes
+      Hash[self.class.attributes.map { |a| [a, send(a)] }]
+    end
+
+    # def serializable_type
+    #   self.class.resource_type
+    # end
+
+    def self.attribute(name)
+      attributes << name.to_sym
+      class_eval { attr_accessor name }
+    end
+
+    def self.attributes
+      @attributes ||= []
+    end
+
+    def self.klass_from_resource_type(obj)
+      LedgerSync.const_get(LedgerSync::Util::StringHelpers.camelcase(obj))
+    end
+
+    def self.reference(name, type)
+      attribute(name)
+      references[name.to_sym] = type
+    end
+
+    def self.references
+      @references ||= {}
+    end
+
+    def self.reference_klass(name)
+      references[name.to_sym]
+    end
+
+    def self.reference_resource_type(name)
+      reference_klass(name).resource_type
+    end
+
+    def self.resource_type
+      @resource_type ||= LedgerSync::Util::StringHelpers.underscore(name.split('::').last).to_sym
+    end
+
+    def ==(other)
+      other.fingerprint == fingerprint
+    end
+  end
+end

data/lib/ledger_sync/resources/customer.rb

@@ -0,0 +1,8 @@
+module LedgerSync
+  class Customer < LedgerSync::Resource
+    attribute :email
+    attribute :name
+    attribute :phone_number
+    # attribute :active
+  end
+end

data/lib/ledger_sync/resources/invoice.rb

@@ -0,0 +1,12 @@
+module LedgerSync
+  class Invoice < LedgerSync::Resource
+    attribute :customer
+    attribute :number
+    attribute :line_items
+    attribute :currency
+
+    def name
+      "Invoice ##{number}"
+    end
+  end
+end

data/lib/ledger_sync/resources/payment.rb

@@ -0,0 +1,11 @@
+module LedgerSync
+  class Payment < LedgerSync::Resource
+    attribute :currency
+    reference :customer, Customer
+    attribute :amount
+
+    def name
+      "Payment: #{amount} #{currency}"
+    end
+  end
+end

data/lib/ledger_sync/resources/product.rb

@@ -0,0 +1,6 @@
+module LedgerSync
+  class Product < LedgerSync::Resource
+    attribute :name
+    attribute :description
+  end
+end

data/lib/ledger_sync/resources/vendor.rb

@@ -0,0 +1,6 @@
+module LedgerSync
+  class Vendor < LedgerSync::Resource
+    attribute :email
+    attribute :name
+  end
+end

data/lib/ledger_sync/result.rb

@@ -0,0 +1,140 @@
+module LedgerSync
+  module ResultBase
+    module HelperMethods
+      def Success(value = nil, *args)
+        self::Success.new(value, *args)
+      end
+
+      def Failure(error = nil, *args)
+        self::Failure.new(error, *args)
+      end
+    end
+
+    def self.included(base)
+      base.const_set('Success', Class.new(Resonad::Success))
+      base::Success.include base::ResultTypeBase if base.const_defined?('ResultTypeBase')
+
+      base.const_set('Failure', Class.new(Resonad::Failure))
+      base::Failure.include base::ResultTypeBase if base.const_defined?('ResultTypeBase')
+
+      base.extend HelperMethods
+    end
+  end
+
+  class Result
+    include ResultBase
+  end
+
+  class OperationResult
+    module ResultTypeBase
+      attr_reader :operation, :response
+
+      def self.included(base)
+        base.class_eval do
+          serialize only: %i[operation response]
+        end
+      end
+
+      def initialize(*args, operation:, response:)
+        @operation = operation
+        @response = response
+        super(*args)
+      end
+    end
+
+    include ResultBase
+  end
+
+  class SyncResult
+    module ResultTypeBase
+      attr_reader :sync
+
+      def self.included(base)
+        base.class_eval do
+          serialize only: %i[sync]
+        end
+      end
+
+      def initialize(*args, sync:, **keywords)
+        @sync = sync
+        super(*args, **keywords)
+      end
+
+      def operations
+        @operations ||= sync.operations
+      end
+    end
+
+    include ResultBase
+  end
+
+
+  class SearchResult
+    module ResultTypeBase
+      attr_reader :resources, :searcher
+
+      def self.included(base)
+        base.class_eval do
+          serialize only: %i[
+            next_searcher
+            previous_searcher
+            resources
+            searcher
+          ]
+        end
+      end
+
+      def self.included(base)
+        base.class_eval do
+          # TODO: removed next and previous searcher, because it causes a string of them.  We should add next_searcher_params which would be easier to serialize.
+          serialize only: %i[resources searcher]
+        end
+      end
+
+      def initialize(*args, searcher:, **keywords)
+        @resources = searcher.resources
+        @searcher = searcher
+        super(*args, **keywords)
+      end
+
+      def next_searcher
+        searcher.next_searcher
+      end
+
+      def next_searcher?
+        !next_searcher.nil?
+      end
+
+      def previous_searcher
+        searcher.previous_searcher
+      end
+
+      def previous_searcher?
+        !previous_searcher.nil?
+      end
+    end
+
+    include ResultBase
+  end
+
+  class ValidationResult
+    module ResultTypeBase
+      attr_reader :validator
+
+      def self.included(base)
+        base.class_eval do
+          serialize only: %i[validator]
+        end
+      end
+
+      def initialize(validator:)
+        raise 'The argument must be a validator' unless validator.is_a?(Util::Validator)
+
+        @validator = validator
+        super(validator)
+      end
+    end
+
+    include ResultBase
+  end
+end