elasticgraph-schema_artifacts 0.18.0.0

data/lib/elastic_graph/schema_artifacts/runtime_metadata/object_type.rb

@@ -0,0 +1,81 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/schema_artifacts/runtime_metadata/graphql_field"
+require "elastic_graph/schema_artifacts/runtime_metadata/hash_dumper"
+require "elastic_graph/schema_artifacts/runtime_metadata/update_target"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      # Provides runtime metadata related to object types.
+      class ObjectType < ::Data.define(
+        :update_targets,
+        :index_definition_names,
+        :graphql_fields_by_name,
+        :elasticgraph_category,
+        # Indicates the name of the GraphQL type from which this type was generated. Note that a `nil` value doesn't
+        # imply that this type was user-defined; we have recently introduced this metadata and are not yet setting
+        # it for all generated GraphQL types. For now, we are only setting it for specific cases where we need it.
+        :source_type,
+        :graphql_only_return_type
+      )
+        UPDATE_TARGETS = "update_targets"
+        INDEX_DEFINITION_NAMES = "index_definition_names"
+        GRAPHQL_FIELDS_BY_NAME = "graphql_fields_by_name"
+        ELASTICGRAPH_CATEGORY = "elasticgraph_category"
+        SOURCE_TYPE = "source_type"
+        GRAPHQL_ONLY_RETURN_TYPE = "graphql_only_return_type"
+
+        def initialize(update_targets:, index_definition_names:, graphql_fields_by_name:, elasticgraph_category:, source_type:, graphql_only_return_type:)
+          graphql_fields_by_name = graphql_fields_by_name.select { |name, field| field.needed?(name) }
+
+          super(
+            update_targets: update_targets,
+            index_definition_names: index_definition_names,
+            graphql_fields_by_name: graphql_fields_by_name,
+            elasticgraph_category: elasticgraph_category,
+            source_type: source_type,
+            graphql_only_return_type: graphql_only_return_type
+          )
+        end
+
+        def self.from_hash(hash)
+          update_targets = hash[UPDATE_TARGETS]&.map do |update_target_hash|
+            UpdateTarget.from_hash(update_target_hash)
+          end || []
+
+          graphql_fields_by_name = hash[GRAPHQL_FIELDS_BY_NAME]&.transform_values do |field_hash|
+            GraphQLField.from_hash(field_hash)
+          end || {}
+
+          new(
+            update_targets: update_targets,
+            index_definition_names: hash[INDEX_DEFINITION_NAMES] || [],
+            graphql_fields_by_name: graphql_fields_by_name,
+            elasticgraph_category: hash[ELASTICGRAPH_CATEGORY]&.to_sym || nil,
+            source_type: hash[SOURCE_TYPE] || nil,
+            graphql_only_return_type: !!hash[GRAPHQL_ONLY_RETURN_TYPE]
+          )
+        end
+
+        def to_dumpable_hash
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            ELASTICGRAPH_CATEGORY => elasticgraph_category&.to_s,
+            GRAPHQL_FIELDS_BY_NAME => HashDumper.dump_hash(graphql_fields_by_name, &:to_dumpable_hash),
+            GRAPHQL_ONLY_RETURN_TYPE => graphql_only_return_type ? true : nil,
+            INDEX_DEFINITION_NAMES => index_definition_names,
+            SOURCE_TYPE => source_type,
+            UPDATE_TARGETS => update_targets.map(&:to_dumpable_hash)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/params.rb

@@ -0,0 +1,81 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/schema_artifacts/runtime_metadata/hash_dumper"
+require "elastic_graph/support/hash_util"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      module Param
+        def self.dump_params_hash(hash_of_params)
+          hash_of_params.sort_by(&:first).to_h { |name, param| [name, param.to_dumpable_hash(name)] }
+        end
+
+        def self.load_params_hash(hash_of_hashes)
+          hash_of_hashes.to_h { |name, hash| [name, from_hash(hash, name)] }
+        end
+
+        def self.from_hash(hash, name)
+          if hash.key?(StaticParam::VALUE)
+            StaticParam.from_hash(hash)
+          else
+            DynamicParam.from_hash(hash, name)
+          end
+        end
+      end
+
+      # Represents metadata about dynamic params we pass to our update scripts.
+      class DynamicParam < ::Data.define(:source_path, :cardinality)
+        SOURCE_PATH = "source_path"
+        CARDINALITY = "cardinality"
+
+        def self.from_hash(hash, name)
+          new(
+            source_path: hash[SOURCE_PATH] || name,
+            cardinality: hash.fetch(CARDINALITY).to_sym
+          )
+        end
+
+        def to_dumpable_hash(param_name)
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            CARDINALITY => cardinality.to_s,
+            SOURCE_PATH => (source_path if source_path != param_name)
+          }
+        end
+
+        def value_for(event_or_prepared_record)
+          case cardinality
+          when :many then Support::HashUtil.fetch_leaf_values_at_path(event_or_prepared_record, source_path) { [] }
+          when :one then Support::HashUtil.fetch_value_at_path(event_or_prepared_record, source_path) { nil }
+          end
+        end
+      end
+
+      class StaticParam < ::Data.define(:value)
+        VALUE = "value"
+
+        def self.from_hash(hash)
+          new(value: hash.fetch(VALUE))
+        end
+
+        def to_dumpable_hash(param_name)
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            VALUE => value
+          }
+        end
+
+        def value_for(event_or_prepared_record)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/relation.rb

@@ -0,0 +1,39 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      class Relation < ::Data.define(:foreign_key, :direction, :additional_filter, :foreign_key_nested_paths)
+        FOREIGN_KEY = "foreign_key"
+        DIRECTION = "direction"
+        ADDITIONAL_FILTER = "additional_filter"
+        FOREIGN_KEY_NESTED_PATHS = "foreign_key_nested_paths"
+
+        def self.from_hash(hash)
+          new(
+            foreign_key: hash[FOREIGN_KEY],
+            direction: hash.fetch(DIRECTION).to_sym,
+            additional_filter: hash[ADDITIONAL_FILTER] || {},
+            foreign_key_nested_paths: hash[FOREIGN_KEY_NESTED_PATHS] || []
+          )
+        end
+
+        def to_dumpable_hash
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            ADDITIONAL_FILTER => additional_filter,
+            DIRECTION => direction.to_s,
+            FOREIGN_KEY => foreign_key,
+            FOREIGN_KEY_NESTED_PATHS => foreign_key_nested_paths
+          }
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/scalar_type.rb

@@ -0,0 +1,94 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/schema_artifacts/runtime_metadata/extension_loader"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      # Provides runtime metadata related to scalar types.
+      class ScalarType < ::Data.define(:coercion_adapter_ref, :indexing_preparer_ref)
+        def self.coercion_adapter_extension_loader
+          @coercion_adapter_extension_loader ||= ExtensionLoader.new(ScalarCoercionAdapterInterface)
+        end
+
+        def self.indexing_preparer_extension_loader
+          @indexing_preparer_extension_loader ||= ExtensionLoader.new(ScalarIndexingPreparerInterface)
+        end
+
+        DEFAULT_COERCION_ADAPTER_REF = {
+          "extension_name" => "ElasticGraph::GraphQL::ScalarCoercionAdapters::NoOp",
+          "require_path" => "elastic_graph/graphql/scalar_coercion_adapters/no_op"
+        }
+
+        DEFAULT_INDEXING_PREPARER_REF = {
+          "extension_name" => "ElasticGraph::Indexer::IndexingPreparers::NoOp",
+          "require_path" => "elastic_graph/indexer/indexing_preparers/no_op"
+        }
+
+        # Loads multiple `ScalarType`s from a hash mapping a scalar type name to its
+        # serialized hash form (matching what `to_dumpable_hash` returns). We expose a method
+        # this way because we want to use a single loader for all `ScalarType`s that
+        # need to get loaded, as it performs some caching for efficiency.
+        def self.load_many(scalar_type_hashes_by_name)
+          scalar_type_hashes_by_name.transform_values do |hash|
+            new(
+              coercion_adapter_ref: hash.fetch("coercion_adapter"),
+              # `indexing_preparer` is new as of Q4 2022, and as such is not present in schema artifacts
+              # dumped before then. Therefore, we allow for the key to not be present in the runtime
+              # metadata--important so that we don't have a "chicken and egg" problem where the rake tasks
+              # that need to be loaded to dump new schema artifacts fail at load time due to the missing key.
+              indexing_preparer_ref: hash.fetch("indexing_preparer", DEFAULT_INDEXING_PREPARER_REF)
+            )
+          end
+        end
+
+        # Loads the coercion adapter. This is done lazily on first access (rather than eagerly in `load_many`)
+        # to allow us to remove a runtime dependency of `elasticgraph-schema_artifacts` on `elasticgraph-graphql`.
+        # The built-in coercion adapters are defined in `elasticgraph-graphql`, and we want to be able to load
+        # runtime metadata without requiring the `elasticgraph-graphql` gem (and its dependencies) to be available.
+        # For example, we use runtime metadata from `elasticgraph-indexer` but do not want `elasticgraph-graphql`
+        # to be loaded as part of that.
+        #
+        # elasticgraph-graphql provides the one caller that calls this method, ensuring that the adapters are
+        # available to be loaded.
+        def load_coercion_adapter
+          Extension.load_from_hash(coercion_adapter_ref, via: self.class.coercion_adapter_extension_loader)
+        end
+
+        def load_indexing_preparer
+          Extension.load_from_hash(indexing_preparer_ref, via: self.class.indexing_preparer_extension_loader)
+        end
+
+        def to_dumpable_hash
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            "coercion_adapter" => load_coercion_adapter.to_dumpable_hash,
+            "indexing_preparer" => load_indexing_preparer.to_dumpable_hash
+          }
+        end
+
+        # `to_h` is used internally by `Value#with` and we want `#to_dumpable_hash` to be the public API.
+        private :to_h
+      end
+
+      class ScalarCoercionAdapterInterface
+        def self.coerce_input(value, ctx)
+        end
+
+        def self.coerce_result(value, ctx)
+        end
+      end
+
+      class ScalarIndexingPreparerInterface
+        def self.prepare_for_indexing(value)
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/schema.rb

@@ -0,0 +1,99 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/schema_artifacts/runtime_metadata/enum"
+require "elastic_graph/schema_artifacts/runtime_metadata/extension"
+require "elastic_graph/schema_artifacts/runtime_metadata/extension_loader"
+require "elastic_graph/schema_artifacts/runtime_metadata/hash_dumper"
+require "elastic_graph/schema_artifacts/runtime_metadata/index_definition"
+require "elastic_graph/schema_artifacts/runtime_metadata/object_type"
+require "elastic_graph/schema_artifacts/runtime_metadata/scalar_type"
+require "elastic_graph/schema_artifacts/runtime_metadata/schema_element_names"
+require "elastic_graph/support/hash_util"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      # Entry point for runtime metadata for an entire schema.
+      class Schema < ::Data.define(
+        :object_types_by_name,
+        :scalar_types_by_name,
+        :enum_types_by_name,
+        :index_definitions_by_name,
+        :schema_element_names,
+        :graphql_extension_modules,
+        :static_script_ids_by_scoped_name
+      )
+        OBJECT_TYPES_BY_NAME = "object_types_by_name"
+        SCALAR_TYPES_BY_NAME = "scalar_types_by_name"
+        ENUM_TYPES_BY_NAME = "enum_types_by_name"
+        INDEX_DEFINITIONS_BY_NAME = "index_definitions_by_name"
+        SCHEMA_ELEMENT_NAMES = "schema_element_names"
+        GRAPHQL_EXTENSION_MODULES = "graphql_extension_modules"
+        STATIC_SCRIPT_IDS_BY_NAME = "static_script_ids_by_scoped_name"
+
+        def self.from_hash(hash, for_context:)
+          object_types_by_name = hash[OBJECT_TYPES_BY_NAME]&.transform_values do |type_hash|
+            ObjectType.from_hash(type_hash)
+          end || {}
+
+          scalar_types_by_name = hash[SCALAR_TYPES_BY_NAME]&.then do |subhash|
+            ScalarType.load_many(subhash)
+          end || {}
+
+          enum_types_by_name = hash[ENUM_TYPES_BY_NAME]&.transform_values do |type_hash|
+            Enum::Type.from_hash(type_hash)
+          end || {}
+
+          index_definitions_by_name = hash[INDEX_DEFINITIONS_BY_NAME]&.transform_values do |index_hash|
+            IndexDefinition.from_hash(index_hash)
+          end || {}
+
+          schema_element_names = SchemaElementNames.from_hash(hash.fetch(SCHEMA_ELEMENT_NAMES))
+
+          loader = ExtensionLoader.new(Module.new)
+          graphql_extension_modules =
+            if for_context == :graphql
+              hash[GRAPHQL_EXTENSION_MODULES]&.map do |ext_mod_hash|
+                Extension.load_from_hash(ext_mod_hash, via: loader)
+              end || []
+            else
+              # Avoid loading GraphQL extrnsion modules if we're not in a GraphQL context. We can't count
+              # on the extension modules even being available to load in other contexts.
+              [] # : ::Array[Extension]
+            end
+
+          static_script_ids_by_scoped_name = hash[STATIC_SCRIPT_IDS_BY_NAME] || {}
+
+          new(
+            object_types_by_name: object_types_by_name,
+            scalar_types_by_name: scalar_types_by_name,
+            enum_types_by_name: enum_types_by_name,
+            index_definitions_by_name: index_definitions_by_name,
+            schema_element_names: schema_element_names,
+            graphql_extension_modules: graphql_extension_modules,
+            static_script_ids_by_scoped_name: static_script_ids_by_scoped_name
+          )
+        end
+
+        def to_dumpable_hash
+          Support::HashUtil.recursively_prune_nils_and_empties_from({
+            # Keys here are ordered alphabetically; please keep them that way.
+            ENUM_TYPES_BY_NAME => HashDumper.dump_hash(enum_types_by_name, &:to_dumpable_hash),
+            GRAPHQL_EXTENSION_MODULES => graphql_extension_modules.map(&:to_dumpable_hash),
+            INDEX_DEFINITIONS_BY_NAME => HashDumper.dump_hash(index_definitions_by_name, &:to_dumpable_hash),
+            OBJECT_TYPES_BY_NAME => HashDumper.dump_hash(object_types_by_name, &:to_dumpable_hash),
+            SCALAR_TYPES_BY_NAME => HashDumper.dump_hash(scalar_types_by_name, &:to_dumpable_hash),
+            SCHEMA_ELEMENT_NAMES => schema_element_names.to_dumpable_hash,
+            STATIC_SCRIPT_IDS_BY_NAME => static_script_ids_by_scoped_name
+          })
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/schema_element_names.rb

@@ -0,0 +1,165 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/constants"
+require "elastic_graph/error"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      # Defines a generic schema element names API. Defined as a separate class to facilitate easy testing.
+      class SchemaElementNamesDefinition
+        def self.new(*element_names)
+          ::Data.define(:form, :overrides, :exposed_name_by_canonical_name, :canonical_name_by_exposed_name) do
+            const_set(:ELEMENT_NAMES, element_names)
+
+            define_method :initialize do |form:, overrides: {}|
+              extend(CONVERTERS.fetch(form.to_s) do
+                raise SchemaError,
+                  "Invalid schema element name form: #{form.inspect}. " \
+                  "Only valid values are: #{CONVERTERS.keys.inspect}."
+              end)
+
+              unused_keys = overrides.keys.map(&:to_s) - element_names.map(&:to_s)
+              if unused_keys.any?
+                raise SchemaError,
+                  "`overrides` contains entries that do not match any schema " \
+                  "elements: #{unused_keys.to_a.inspect}. Are any misspelled?"
+              end
+
+              exposed_name_by_canonical_name = element_names.each_with_object({}) do |element, names|
+                names[element] = overrides.fetch(element) do
+                  overrides.fetch(element.to_s) do
+                    normalize_case(element.to_s)
+                  end
+                end.to_s
+              end.freeze
+
+              canonical_name_by_exposed_name = exposed_name_by_canonical_name.invert
+              validate_no_name_collisions(canonical_name_by_exposed_name, exposed_name_by_canonical_name)
+
+              super(
+                form: form,
+                overrides: overrides,
+                exposed_name_by_canonical_name: exposed_name_by_canonical_name,
+                canonical_name_by_exposed_name: canonical_name_by_exposed_name
+              )
+            end
+
+            # standard:disable Lint/NestedMethodDefinition
+            element_names.each do |element|
+              method_name = SnakeCaseConverter.normalize_case(element.to_s)
+              define_method(method_name) { exposed_name_by_canonical_name.fetch(element) }
+            end
+
+            # Returns the _canonical_ name for the given _exposed name_. The canonical name
+            # is the name we use within the source code of our framework; the exposed name
+            # is the name exposed in the specific GraphQL schema based on the configuration
+            # of the project.
+            def canonical_name_for(exposed_name)
+              canonical_name_by_exposed_name[exposed_name.to_s]
+            end
+
+            def self.from_hash(hash)
+              new(
+                form: hash.fetch(FORM).to_sym,
+                overrides: hash[OVERRIDES] || {}
+              )
+            end
+
+            def to_dumpable_hash
+              {
+                # Keys here are ordered alphabetically; please keep them that way.
+                FORM => form.to_s,
+                OVERRIDES => overrides
+              }
+            end
+
+            def to_s
+              "#<#{self.class.name} form=#{form}, overrides=#{overrides}>"
+            end
+            alias_method :inspect, :to_s
+
+            private
+
+            def validate_no_name_collisions(canonical_name_by_exposed_name, exposed_name_by_canonical_name)
+              return if canonical_name_by_exposed_name.size == exposed_name_by_canonical_name.size
+
+              collisions = exposed_name_by_canonical_name
+                .group_by { |k, v| v }
+                .reject { |v, kv_pairs| kv_pairs.size == 1 }
+                .transform_values { |kv_pairs| kv_pairs.map(&:first) }
+                .map do |duplicate_exposed_name, canonical_names|
+                  "#{canonical_names.inspect} all map to the same exposed name: #{duplicate_exposed_name}"
+                end.join(" and ")
+
+              raise SchemaError, collisions
+            end
+            # standard:enable Lint/NestedMethodDefinition
+          end
+        end
+
+        FORM = "form"
+        OVERRIDES = "overrides"
+
+        module SnakeCaseConverter
+          extend self
+
+          def normalize_case(name)
+            name.gsub(/([[:upper:]])/) { "_#{$1.downcase}" }
+          end
+        end
+
+        module CamelCaseConverter
+          extend self
+
+          def normalize_case(name)
+            name.gsub(/_(\w)/) { $1.upcase }
+          end
+        end
+
+        CONVERTERS = {
+          "snake_case" => SnakeCaseConverter,
+          "camelCase" => CamelCaseConverter
+        }
+      end
+
+      SchemaElementNames = SchemaElementNamesDefinition.new(
+        # Filter arg and operation names:
+        :filter,
+        :equal_to_any_of, :gt, :gte, :lt, :lte, :matches, :matches_phrase, :matches_query, :any_of, :all_of, :not,
+        :time_of_day, :any_satisfy,
+        # Directives
+        :eg_latency_slo, :ms,
+        # For sorting.
+        :order_by,
+        # For aggregation
+        :grouped_by, :count, :count_detail, :aggregated_values, :sub_aggregations,
+        # Date/time grouping aggregation fields
+        :as_date_time, :as_date, :as_time_of_day, :as_day_of_week,
+        # Date/time grouping aggregation arguments
+        :offset, :amount, :unit, :time_zone, :truncation_unit,
+        # TODO: Drop support for legacy grouping schema that uses `granularity` and `offset_days`
+        :granularity, :offset_days,
+        # For aggregation counts.
+        :approximate_value, :exact_value, :upper_bound,
+        # For pagination.
+        :first, :after, :last, :before,
+        :edges, :node, :nodes, :cursor,
+        :page_info, :start_cursor, :end_cursor, :total_edge_count, :has_previous_page, :has_next_page,
+        # Subfields of `GeoLocation`/`GeoLocationFilterInput`:
+        :latitude, :longitude, :near, :max_distance,
+        # Subfields of `MatchesQueryFilterInput`/`MatchesPhraseFilterInput`
+        :query, :phrase, :allowed_edits_per_term, :require_all_terms,
+        # Aggregated values field names:
+        :exact_min, :exact_max, :approximate_min, :approximate_max, :approximate_avg, :approximate_sum, :exact_sum,
+        :approximate_distinct_value_count
+      )
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/sort_field.rb

@@ -0,0 +1,47 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/error"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      class SortField < ::Data.define(:field_path, :direction)
+        def initialize(field_path:, direction:)
+          unless direction == :asc || direction == :desc
+            raise SchemaError, "Sort direction `#{direction.inspect}` is invalid; it must be `:asc` or `:desc`"
+          end
+
+          super(field_path: field_path, direction: direction)
+        end
+
+        FIELD_PATH = "field_path"
+        DIRECTION = "direction"
+
+        def self.from_hash(hash)
+          new(
+            field_path: hash[FIELD_PATH],
+            direction: hash.fetch(DIRECTION).to_sym
+          )
+        end
+
+        def to_dumpable_hash
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            DIRECTION => direction.to_s,
+            FIELD_PATH => field_path
+          }
+        end
+
+        def to_query_clause
+          {field_path => {"order" => direction.to_s}}
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/schema_artifacts/runtime_metadata/update_target.rb

@@ -0,0 +1,80 @@
+# Copyright 2024 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/constants"
+require "elastic_graph/schema_artifacts/runtime_metadata/params"
+
+module ElasticGraph
+  module SchemaArtifacts
+    module RuntimeMetadata
+      # Provides runtime metadata related to the targets of datastore `update` calls.
+      class UpdateTarget < ::Data.define(
+        :type,
+        :relationship,
+        :script_id,
+        :id_source,
+        :routing_value_source,
+        :rollover_timestamp_value_source,
+        :data_params,
+        :metadata_params
+      )
+        TYPE = "type"
+        RELATIONSHIP = "relationship"
+        SCRIPT_ID = "script_id"
+        ID_SOURCE = "id_source"
+        ROUTING_VALUE_SOURCE = "routing_value_source"
+        ROLLOVER_TIMESTAMP_VALUE_SOURCE = "rollover_timestamp_value_source"
+        DATA_PARAMS = "data_params"
+        METADATA_PARAMS = "metadata_params"
+
+        def self.from_hash(hash)
+          new(
+            type: hash[TYPE],
+            relationship: hash[RELATIONSHIP],
+            script_id: hash[SCRIPT_ID],
+            id_source: hash[ID_SOURCE],
+            routing_value_source: hash[ROUTING_VALUE_SOURCE],
+            rollover_timestamp_value_source: hash[ROLLOVER_TIMESTAMP_VALUE_SOURCE],
+            data_params: Param.load_params_hash(hash[DATA_PARAMS] || {}),
+            metadata_params: Param.load_params_hash(hash[METADATA_PARAMS] || {})
+          )
+        end
+
+        def to_dumpable_hash
+          {
+            # Keys here are ordered alphabetically; please keep them that way.
+            DATA_PARAMS => Param.dump_params_hash(data_params),
+            ID_SOURCE => id_source,
+            METADATA_PARAMS => Param.dump_params_hash(metadata_params),
+            RELATIONSHIP => relationship,
+            ROLLOVER_TIMESTAMP_VALUE_SOURCE => rollover_timestamp_value_source,
+            ROUTING_VALUE_SOURCE => routing_value_source,
+            SCRIPT_ID => script_id,
+            TYPE => type
+          }
+        end
+
+        def for_normal_indexing?
+          script_id == INDEX_DATA_UPDATE_SCRIPT_ID
+        end
+
+        def params_for(doc_id:, event:, prepared_record:)
+          data = data_params.to_h do |name, param|
+            [name, param.value_for(prepared_record)]
+          end
+
+          meta = metadata_params.to_h do |name, param|
+            [name, param.value_for(event)]
+          end
+
+          meta.merge({"id" => doc_id, "data" => data})
+        end
+      end
+    end
+  end
+end