Class: Muninn::Cache::KeyBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/muninn/cache/key_builder.rb

Class Method Summary collapse

Class Method Details

.build(namespace:, scope:, deps: {}, fingerprint: nil, version: nil, mode: nil, entity_id: nil) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/muninn/cache/key_builder.rb', line 9

def self.build(namespace:, scope:, deps: {}, fingerprint: nil, version: nil, mode: nil, entity_id: nil)
  scope_name = scope.fetch(:scope_name)
  scope_id = scope.fetch(:scope_id)
  version ||= VersionCounter.get(namespace: namespace, scope_name: scope_name, scope_id: scope_id)
  deps_versioned = build_deps(deps)
  parts = []
  parts << "scope:#{scope_name}:#{scope_id}"
  parts << "namespace:#{namespace}"
  parts << "entity:#{entity_id}" if entity_id
  parts << "mode:#{mode}" if mode
  parts << "deps:#{deps_versioned}" if deps_versioned
  parts << "fingerprint:#{fingerprint}" if fingerprint
  parts << "version:#{version}"
  canonical = parts.join(":")
  "cache:#{Digest::SHA256.hexdigest(canonical)}"
end

.build_deps(deps, scope_name: "entity") ⇒ Object 



53
54
55
56
57
58
59
60
 
# File 'lib/muninn/cache/key_builder.rb', line 53

def self.build_deps(deps, scope_name: "entity")
  return nil if deps.nil? || deps.empty?

  deps.map do |namespace, id|
    version = VersionCounter.get(namespace: namespace, scope_name: scope_name, scope_id: id)
    "#{namespace}:#{id}:v#{version}"
  end.sort.join("|")
end

.fingerprint_from_params(params:, allowed_keys: [], context: {}) ⇒ Object 



26
27
28
29
 
# File 'lib/muninn/cache/key_builder.rb', line 26

def self.fingerprint_from_params(params:, allowed_keys: [], context: {})
  payload = normalize_payload(params, allowed_keys: allowed_keys).merge(context)
  Digest::SHA256.hexdigest(JSON.generate(payload))
end

.normalize_payload(params, allowed_keys: []) ⇒ Object 



31
32
33
34
35
36
37
38
 
# File 'lib/muninn/cache/key_builder.rb', line 31

def self.normalize_payload(params, allowed_keys: [])
  data = params || {}
  data = data.to_h if data.respond_to?(:to_h)
  data = data.deep_symbolize_keys if data.respond_to?(:deep_symbolize_keys)
  allowed = allowed_keys.map(&:to_sym)
  data = data.slice(*allowed) if allowed.any?
  normalize_value(data)
end

.normalize_value(value) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/muninn/cache/key_builder.rb', line 40

def self.normalize_value(value)
  case value
  when Hash
    value.keys.sort.each_with_object({}) do |key, acc|
      acc[key] = normalize_value(value[key])
    end
  when Array
    value.map { |item| normalize_value(item) }.sort_by { |item| item.to_s }
  else
    value
  end
end