Class: ElasticGraph::SchemaArtifacts::RuntimeMetadata::SchemaElementNamesDefinition

Inherits:
Object
  • Object
show all
Defined in:
lib/elastic_graph/schema_artifacts/runtime_metadata/schema_element_names.rb

Overview

Defines a generic schema element names API. Defined as a separate class to facilitate easy testing.

Defined Under Namespace

Modules: CamelCaseConverter, SnakeCaseConverter

Constant Summary collapse

FORM = 
"form"
OVERRIDES = 
"overrides"
CONVERTERS = 
{
  "snake_case" => SnakeCaseConverter,
  "camelCase" => CamelCaseConverter
}

Class Method Summary collapse

Class Method Details

.new(*element_names) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/elastic_graph/schema_artifacts/runtime_metadata/schema_element_names.rb', line 19

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: {}|
      converter = CONVERTERS.fetch(form.to_s) do
        raise Errors::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 Errors::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
            converter.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

    # Converts a name to the configured case form (snake_case or camelCase).
    def normalize_case(name)
      CONVERTERS.fetch(form.to_s).normalize_case(name)
    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 Errors::SchemaError, collisions
    end
    # standard:enable Lint/NestedMethodDefinition
  end
end