reactor_sdk 0.1.0

data/lib/reactor_sdk/resources/note.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+##
+# @file resources/note.rb
+# @description Represents an Adobe Launch Note resource.
+#
+#   Notes are textual annotations attached to notable Launch resources such
+#   as rules, data elements, libraries, properties, extensions, and rule
+#   components.
+#
+# @domain Resources
+#
+
+module ReactorSDK
+  module Resources
+    class Note < BaseResource
+      # @return [String] Note body text
+      attribute :text
+
+      # @return [String] Display name of the note author
+      attribute :author_display_name
+
+      # @return [String] Email of the note author
+      attribute :author_email
+
+      # @return [String] ISO8601 timestamp when the note was created
+      attribute :created_at
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        "#<ReactorSDK::Resources::Note id=#{id.inspect} text=#{text.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/profile.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ReactorSDK
+  module Resources
+    class Profile < BaseResource
+      attribute :active_org
+      attribute :expires_in
+      attribute :display_name
+      attribute :job_function
+      attribute :email
+      attribute :organizations, default: {}
+
+      def rights
+        Array(meta['rights'])
+      end
+
+      def inspect
+        "#<ReactorSDK::Resources::Profile id=#{id.inspect} email=#{email.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/property.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+##
+# @file resources/property.rb
+# @description Represents an Adobe Launch Property resource.
+#
+#   A Property is the primary container in Adobe Launch. All rules,
+#   data elements, extensions, environments, and libraries belong
+#   to a property. A company can have many properties.
+#
+# @domain Resources
+# @see https://developer.adobe.com/experience-platform/documentation/tags/api/endpoints/properties/
+#
+
+module ReactorSDK
+  module Resources
+    class Property < BaseResource
+      # @return [String] Display name of the property
+      attribute :name
+
+      # @return [String] Platform type — one of: "web", "mobile", "edge"
+      attribute :platform
+
+      # @return [Boolean] Whether the property is enabled
+      attribute :enabled, as: :boolean
+
+      # @return [Array<String>] Domains associated with this property (web only)
+      attribute :domains, default: []
+
+      # @return [String] ISO8601 timestamp when the property was created
+      attribute :created_at
+
+      # @return [String] ISO8601 timestamp when the property was last updated
+      attribute :updated_at
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        "#<ReactorSDK::Resources::Property id=#{id.inspect} name=#{name.inspect} platform=#{platform.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/revision.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+##
+# @file resources/revision.rb
+# @description Represents an Adobe Launch Revision resource.
+#
+#   Revisions are point-in-time snapshots of any revisable resource —
+#   rules, data elements, and extensions. Every time a revisable resource
+#   is saved, Adobe creates a new revision capturing its full state at
+#   that moment.
+#
+#   Revisions are the foundation of LaunchGuard's diff engine. By fetching
+#   the revision from each library and comparing the two snapshots, the
+#   exact field-level changes between versions can be determined.
+#
+#   The full resource snapshot is returned in the JSON:API `included`
+#   array when fetching a revision with `GET /revisions/:id`. This class
+#   extracts that snapshot and exposes it alongside the revision metadata.
+#
+#   Upstream resolution: when a resource does not exist in the target
+#   library, the app walks upstream through the environment chain
+#   (Development → Staging → Production) to find the nearest version
+#   to diff against. The SDK provides the data — the app owns this logic.
+#
+# @domain Resources
+# @see https://developer.adobe.com/experience-platform/documentation/tags/api/endpoints/revisions/
+#
+
+module ReactorSDK
+  module Resources
+    class Revision < BaseResource
+      # @return [String] ISO8601 timestamp when this revision was created
+      attribute :created_at
+
+      # @return [String, nil] The action that triggered this revision
+      #   Common values: "created", "updated", "published", "rejected"
+      attribute :activity_type
+
+      ##
+      # Returns the full attributes snapshot of the resource at this revision.
+      #
+      # Adobe returns the revisioned resource in the JSON:API `included` array
+      # when fetching a revision. This method extracts those attributes so the
+      # app can compare two snapshots field by field.
+      #
+      # Returns an empty Hash if the included snapshot is not present —
+      # this happens when fetching a revision list (GET /rules/:id/revisions)
+      # rather than a single revision (GET /revisions/:id). Always use
+      # revisions.find(id) when you need the full snapshot.
+      #
+      # @return [Hash] Full attributes of the revisioned resource, or {} if absent
+      #
+      def entity_snapshot
+        return {} if @included_entity.nil?
+
+        @included_entity.fetch('attributes', {})
+      end
+
+      ##
+      # Returns the full relationships snapshot of the resource at this revision.
+      #
+      # @return [Hash]
+      #
+      def entity_relationships
+        return {} if @included_entity.nil?
+
+        @included_entity.fetch('relationships', {})
+      end
+
+      ##
+      # Returns the Adobe ID of the resource this revision belongs to.
+      # Extracted from the JSON:API relationships on the revision.
+      #
+      # @return [String, nil] Resource ID (e.g. "RL123") or nil if not present
+      #
+      attr_reader :entity_id
+
+      ##
+      # Returns the JSON:API type of the resource this revision belongs to.
+      # Extracted from the JSON:API relationships on the revision.
+      #
+      # @return [String, nil] Resource type (e.g. "rules") or nil if not present
+      #
+      attr_reader :entity_type
+
+      ##
+      # Overrides BaseResource initializer to extract the included entity
+      # and relationship data from the raw JSON:API response.
+      #
+      # In addition to standard id/type/attributes/meta, the Revision resource
+      # accepts two extra keyword arguments:
+      #   - included_entity: the raw included resource hash from the API response
+      #   - relationships:   the relationships hash from the revision data object
+      #
+      # These are passed by the ResponseParser when building a Revision from
+      # a full GET /revisions/:id response.
+      #
+      # @param id               [String] Adobe revision ID
+      # @param type             [String] JSON:API type ("revisions")
+      # @param attributes       [Hash]   Revision attributes
+      # @param meta             [Hash]   Optional metadata
+      # @param included_entity  [Hash, nil] Raw included resource from API response
+      # @param relationships    [Hash, nil] Relationships hash from the revision
+      #
+      def initialize(
+        id:,
+        type:,
+        attributes:      {},
+        meta:            {},
+        relationships:   {},
+        included_entity: nil,
+        revision_relationships: nil
+      )
+        super(
+          id: id,
+          type: type,
+          attributes: attributes,
+          meta: meta,
+          relationships: relationships
+        )
+        @included_entity = included_entity
+        extract_entity_identity(revision_relationships || relationships)
+      end
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        '#<ReactorSDK::Resources::Revision ' \
+          "id=#{id.inspect} " \
+          "activity_type=#{activity_type.inspect} " \
+          "entity_id=#{entity_id.inspect} " \
+          "entity_type=#{entity_type.inspect}>"
+      end
+
+      private
+
+      ##
+      # Extracts the entity ID and type from the revision's relationships hash.
+      # Adobe stores the revisioned resource reference under relationships.entity.data.
+      #
+      # @param relationships [Hash, nil] The relationships object from the API response
+      # @sideeffect Sets @entity_id and @entity_type
+      #
+      def extract_entity_identity(relationships)
+        return unless relationships.is_a?(Hash)
+
+        entity_data = relationships.dig('entity', 'data')
+        return unless entity_data.is_a?(Hash)
+
+        @entity_id   = entity_data['id']
+        @entity_type = entity_data['type']
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/rule.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+##
+# @file resources/rule.rb
+# @description Represents an Adobe Launch Rule resource.
+#
+#   Rules define the logic that Adobe Launch executes — they consist
+#   of conditions (when to run) and actions (what to do). Rules belong
+#   to a property and are versioned via the revisions endpoint.
+#
+# @domain Resources
+# @see https://developer.adobe.com/experience-platform/documentation/tags/api/endpoints/rules/
+#
+
+module ReactorSDK
+  module Resources
+    class Rule < BaseResource
+      # @return [String] Display name of the rule
+      attribute :name
+
+      # @return [Boolean] Whether the rule is enabled
+      attribute :enabled, as: :boolean
+
+      # @return [String] ISO8601 timestamp when the rule was created
+      attribute :created_at
+
+      # @return [String] ISO8601 timestamp when the rule was last updated
+      attribute :updated_at
+
+      # @return [String, nil] ISO8601 timestamp when the rule was last published
+      attribute :published_at
+
+      # @return [String, nil] ISO8601 timestamp when the rule was last revised
+      attribute :revised_at
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        "#<ReactorSDK::Resources::Rule id=#{id.inspect} name=#{name.inspect} enabled=#{enabled.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/rule_component.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+##
+# @file resources/rule_component.rb
+# @description Represents an Adobe Launch Rule Component resource.
+#
+#   Rule components are the individual conditions and actions that make
+#   up a rule. Each component references a delegate (an extension-provided
+#   function) via its delegate_descriptor_id and carries a settings hash
+#   specific to that delegate.
+#
+#   The settings field varies significantly across extension types:
+#     - Core custom code actions store JavaScript or HTML in settings["source"]
+#     - Adobe Web SDK actions store XDM objects and data objects
+#     - Adobe Analytics actions store variable mappings
+#     - Third-party extensions define their own settings structure
+#
+#   Use parsed_settings to access the full settings object as a Ruby Hash.
+#   This is the primary accessor for component configuration — it covers
+#   all extension types uniformly, exactly as Adobe Launch displays settings
+#   in its own version comparison UI.
+#
+# @domain Resources
+# @see https://developer.adobe.com/experience-platform/documentation/tags/api/endpoints/rule-components/
+#
+
+module ReactorSDK
+  module Resources
+    class RuleComponent < BaseResource
+      # @return [String] Display name of the rule component
+      attribute :name
+
+      # @return [String] Identifies the extension delegate powering this component
+      #   Format: "extension-package-name::component-type::component-name"
+      #   Example: "core::actions::custom-code"
+      #   Example: "adobe-alloy::actions::send-event"
+      attribute :delegate_descriptor_id
+
+      # @return [String] Raw settings value exactly as returned by Adobe.
+      #   May be a JSON-encoded string or a plain Hash depending on the extension.
+      #   Use parsed_settings for reliable Hash access.
+      attribute :settings
+
+      # @return [Integer, nil] Execution order of this component within the rule
+      attribute :order
+
+      # @return [Float, Integer, nil] Execution order of this component within the rule graph
+      attribute :rule_order
+
+      # @return [String] ISO8601 timestamp when the component was created
+      attribute :created_at
+
+      # @return [String] ISO8601 timestamp when the component was last updated
+      attribute :updated_at
+
+      ##
+      # Returns the settings field parsed into a Ruby Hash.
+      #
+      # This is the primary accessor for component configuration. It handles
+      # all extension types uniformly:
+      #   - Core custom code (JavaScript, HTML) stored as JSON-encoded string
+      #   - Adobe Web SDK XDM objects and data objects
+      #   - Adobe Analytics variable mappings and custom setup blocks
+      #   - Any third-party extension settings structure
+      #
+      # The app can render this as formatted JSON for display and diffing —
+      # exactly as Adobe Launch does in its own version comparison UI.
+      #
+      # Behaviour by input type:
+      #   - JSON-encoded string → parsed into Hash
+      #   - Already a Hash     → returned as-is
+      #   - nil or blank       → returns empty Hash
+      #   - Unparseable string → returns empty Hash, raw value still on settings
+      #
+      # The raw settings value is always preserved on the settings attribute
+      # unchanged — this method never modifies the underlying data.
+      #
+      # @return [Hash] Parsed settings or empty hash if nil, blank, or unparseable
+      #
+      def parsed_settings
+        raw = @attributes['settings']
+        return {} if raw.nil? || raw == ''
+        return raw if raw.is_a?(Hash)
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        {}
+      end
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        '#<ReactorSDK::Resources::RuleComponent ' \
+          "id=#{id.inspect} " \
+          "name=#{name.inspect} " \
+          "delegate=#{delegate_descriptor_id.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/search_results.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ReactorSDK
+  module Resources
+    class SearchResults
+      include Enumerable
+
+      attr_reader :results, :meta
+
+      def initialize(results:, meta: {})
+        @results = results
+        @meta = meta
+      end
+
+      def each(&)
+        results.each(&)
+      end
+
+      def total_hits
+        meta.fetch('total_hits', results.length)
+      end
+
+      def inspect
+        "#<ReactorSDK::Resources::SearchResults total_hits=#{total_hits} size=#{results.length}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/secret.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ReactorSDK
+  module Resources
+    class Secret < BaseResource
+      attribute :name
+      attribute :type_of
+      attribute :credentials, default: {}
+      attribute :created_at
+      attribute :updated_at
+
+      def inspect
+        "#<ReactorSDK::Resources::Secret id=#{id.inspect} name=#{name.inspect} type_of=#{type_of.inspect}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/upstream_chain.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+##
+# @file resources/upstream_chain.rb
+# @description Represents the full upstream lookup result for one resource.
+#
+#   This wrapper captures the target library context and the ordered upstream
+#   entries that were inspected. It exists so callers can ask higher-level
+#   questions such as:
+#     - What revision does the target library currently contain?
+#     - Which upstream library is the nearest match?
+#     - Did the resource disappear entirely upstream?
+#
+
+module ReactorSDK
+  module Resources
+    class UpstreamChain
+      include Enumerable
+
+      attr_reader :resource_id,
+                  :resource_type,
+                  :property_id,
+                  :target_library_id,
+                  :target_resource,
+                  :target_revision_id,
+                  :entries
+
+      def initialize(
+        resource_id:,
+        resource_type:,
+        property_id:,
+        target_library_id:,
+        target_resource:,
+        target_revision_id:,
+        entries:
+      )
+        @resource_id = resource_id
+        @resource_type = resource_type
+        @property_id = property_id
+        @target_library_id = target_library_id
+        @target_resource = target_resource
+        @target_revision_id = target_revision_id
+        @entries = Array(entries)
+      end
+
+      ##
+      # @yieldparam entry [ReactorSDK::Resources::UpstreamChainEntry]
+      # @return [Array<ReactorSDK::Resources::UpstreamChainEntry>]
+      #
+      def each(&)
+        @entries.each(&)
+      end
+
+      ##
+      # @return [ReactorSDK::Resources::UpstreamChainEntry, nil]
+      #
+      def nearest_match
+        @entries.find(&:present?)
+      end
+
+      ##
+      # @return [Boolean] true when any upstream library contains the resource
+      #
+      def found?
+        !nearest_match.nil?
+      end
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        '#<ReactorSDK::Resources::UpstreamChain ' \
+          "resource_id=#{resource_id.inspect} " \
+          "resource_type=#{resource_type.inspect} " \
+          "target_library_id=#{target_library_id.inspect} " \
+          "entries=#{entries.length}>"
+      end
+    end
+  end
+end

data/lib/reactor_sdk/resources/upstream_chain_entry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+##
+# @file resources/upstream_chain_entry.rb
+# @description Represents one upstream-library lookup for a single resource.
+#
+#   This object is not returned directly by the Adobe API. It is assembled by
+#   ReactorSDK when resolving a resource across the ordered upstream library
+#   chain. Each entry answers:
+#     - which library was inspected
+#     - which stage that library belongs to
+#     - whether the resource exists in that library
+#     - which revision ID and revision snapshot were found
+#
+
+module ReactorSDK
+  module Resources
+    class UpstreamChainEntry
+      attr_reader :library, :stage, :resource, :revision_id, :revision
+
+      def initialize(library:, stage:, resource:, revision_id:, revision:)
+        @library = library
+        @stage = stage
+        @resource = resource
+        @revision_id = revision_id
+        @revision = revision
+      end
+
+      ##
+      # @return [Boolean] true when the resource exists in this upstream library
+      #
+      def present?
+        !@resource.nil?
+      end
+
+      ##
+      # @return [Hash, nil] Point-in-time snapshot for the matched revision
+      #
+      def entity_snapshot
+        @revision&.entity_snapshot
+      end
+
+      ##
+      # @return [String] Human-readable representation
+      #
+      def inspect
+        '#<ReactorSDK::Resources::UpstreamChainEntry ' \
+          "library_id=#{library.id.inspect} " \
+          "stage=#{stage.inspect} " \
+          "resource_id=#{resource&.id.inspect} " \
+          "revision_id=#{revision_id.inspect}>"
+      end
+    end
+  end
+end