rest-easy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45f897c2480954795efd3cae882ba4502ba38f7eeeb857f4a5a5ae897f9cc8f1
+  data.tar.gz: e7f42336f9d418c2c97b628cc5d393bdfd07472152c452ca60ebac770da02f49
+SHA512:
+  metadata.gz: 7e2b2ad556be8737a7f85247e1d70a391d16bae3df56b6c9203ac3f746a6c54611218b18d34340d2b078a4f2b9eeb9c85ad15083e4cf75de07e8dc7c93033f45
+  data.tar.gz: b3fce6ba8f12d94e89df4b7325abc07d1ead9dd687b460cddd7df2c4264b21beeb1b85eba6770dc82a8894100be4d5d7b9f650b84b15d9fc6e474fc7b6d73744

data/lib/rest_easy/attribute.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RestEasy
+  # Stores the definition of a single attribute declared via the Resource DSL.
+  class Attribute
+    attr_reader :model_name, :api_name, :type, :flags, :parse_block, :serialise_block, :source_fields, :target_fields
+
+    def initialize(model_name:, api_name:, type:, flags: [], parse_block: nil, serialise_block: nil, source_fields: [], target_fields: [])
+      @model_name = model_name.to_sym
+      @api_name = api_name.to_s
+      @type = type
+      @flags = Array(flags).map(&:to_sym)
+      @parse_block = parse_block
+      @serialise_block = serialise_block
+      @source_fields = source_fields
+      @target_fields = target_fields
+    end
+
+    def required?
+      @flags.include?(:required)
+    end
+
+    def optional?
+      @flags.include?(:optional)
+    end
+
+    def read_only?
+      @flags.include?(:read_only)
+    end
+
+    def key?
+      @flags.include?(:key)
+    end
+
+    def synthetic?
+      @flags.include?(:synthetic)
+    end
+
+    def coerce(value)
+      @type[value]
+    rescue Dry::Types::ConstraintError => e
+      raise RestEasy::ConstraintError.new(@model_name, value, e.message)
+    rescue Dry::Types::CoercionError => e
+      raise RestEasy::ConstraintError.new(@model_name, value, e.message)
+    end
+
+    def parse_value(*raw_values)
+      value = @parse_block ? @parse_block.call(*raw_values) : raw_values.first
+      coerce(value)
+    end
+
+    def serialise_value(*model_values)
+      if @serialise_block
+        @serialise_block.call(*model_values)
+      else
+        to_json_value(model_values.first)
+      end
+    end
+
+    private
+
+    def to_json_value(value)
+      case value
+      when ::String, ::Integer, ::Float, ::NilClass, true, false, ::Array, ::Hash
+        value
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/rest_easy/auth/basic.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module RestEasy
+  module Auth
+    # HTTP Basic authentication.
+    # Encodes username:password as Base64 and sets the Authorization header.
+    class Basic
+      def initialize(username:, password:)
+        @encoded = Base64.strict_encode64("#{username}:#{password}")
+      end
+
+      def apply(request)
+        request.headers["Authorization"] = "Basic #{@encoded}"
+      end
+
+      def on_rejected(response)
+        raise RestEasy::AuthenticationError, "Authentication failed: #{response.status}"
+      end
+    end
+  end
+end

data/lib/rest_easy/auth/null.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RestEasy
+  module Auth
+    # No-op auth for APIs that don't require authentication,
+    # or when auth is handled at the transport level (e.g. mTLS).
+    class Null
+      def apply(request)
+        # no-op
+      end
+
+      def on_rejected(response)
+        raise RestEasy::RequestError.new(response)
+      end
+    end
+  end
+end

data/lib/rest_easy/auth/psk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RestEasy
+  module Auth
+    # Pre-shared key (API key) authentication.
+    # Applies a static key as a request header.
+    class PSK
+      def initialize(api_key:, header_name: "Authorization", header_prefix: "Bearer")
+        @api_key = api_key
+        @header_name = header_name
+        @header_prefix = header_prefix
+      end
+
+      def apply(request)
+        request.headers[@header_name] = "#{@header_prefix} #{@api_key}"
+      end
+
+      def on_rejected(response)
+        raise RestEasy::RequestError.new(response)
+      end
+    end
+  end
+end

data/lib/rest_easy/auth.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RestEasy
+  module Auth
+  end
+end

data/lib/rest_easy/conventions.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RestEasy
+  module Conventions
+    class PascalCase
+      def parse(api_name)
+        # "DocumentNumber" → :document_number
+        api_name.to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .to_sym
+      end
+
+      def serialise(model_name)
+        # :document_number → "DocumentNumber"
+        model_name.to_s
+          .split("_")
+          .map(&:capitalize)
+          .join
+      end
+    end
+
+    class CamelCase
+      def parse(api_name)
+        # "documentNumber" → :document_number
+        api_name.to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .to_sym
+      end
+
+      def serialise(model_name)
+        # :document_number → "documentNumber"
+        parts = model_name.to_s.split("_")
+        (parts[0] + parts[1..].map(&:capitalize).join)
+      end
+    end
+
+    class SnakeCase
+      def parse(api_name)
+        # "document_number" → :document_number
+        api_name.to_s.to_sym
+      end
+
+      def serialise(model_name)
+        # :document_number → "document_number"
+        model_name.to_s
+      end
+    end
+
+    REGISTRY = {
+      PascalCase: PascalCase.new,
+      camelCase: CamelCase.new,
+      snake_case: SnakeCase.new
+    }.freeze
+
+    def self.resolve(convention)
+      case convention
+      when Symbol
+        REGISTRY.fetch(convention) do
+          raise ArgumentError, "Unknown convention: #{convention}. Available: #{REGISTRY.keys.join(', ')}"
+        end
+      else
+        convention # Custom object, pass through
+      end
+    end
+  end
+end

data/lib/rest_easy/meta.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RestEasy
+  class Meta
+    def initialize(new_record: false, saved: false, **defaults)
+      @data = { new: new_record, saved: saved, **defaults }
+    end
+
+    def new?
+      @data[:new]
+    end
+
+    def saved?
+      @data[:saved]
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      if key.end_with?("=")
+        @data[key.chomp("=").to_sym] = args.first
+      elsif key.end_with?("?")
+        !!@data[key.chomp("?").to_sym]
+      else
+        @data[name.to_sym]
+      end
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/rest_easy/refinements.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RestEasy
+  module Refinements
+    refine Symbol do
+      def <=>(other)
+        [self, other]
+      end
+    end
+
+    refine String do
+      def <=>(other)
+        [self, other]
+      end
+    end
+  end
+end