# frozen_string_literal: true

module JSONAPI

# Contains a hash of resource types which contain a hash of resources, relationships and primary status keyed by

# resource id.

class ResourceSet

attr_reader :resource_klasses, :populated

def initialize(source, include_related = nil, options = nil)

@populated = false

tree = if source.is_a?(JSONAPI::ResourceTree)

source

elsif source.class < JSONAPI::BasicResource

JSONAPI::PrimaryResourceTree.new(resource: source, include_related: include_related, options: options)

elsif source.is_a?(Array)

JSONAPI::PrimaryResourceTree.new(resources: source, include_related: include_related, options: options)

end

if tree

@resource_klasses = flatten_resource_tree(tree)

end

end

def populate!(serializer, context, options)

return if @populated

# For each resource klass we want to generate the caching key

# Hash for collecting types and ids

# @type [Hash<Class<Resource>, Id[]]]

missed_resource_ids = {}

# Array for collecting CachedResponseFragment::Lookups

# @type [Lookup[]]

lookups = []

# Step One collect all of the lookups for the cache, or keys that don't require cache access

@resource_klasses.each_key do |resource_klass|

missed_resource_ids[resource_klass] ||= []

serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")

context_json = resource_klass.attribute_caching_context(context).to_json

context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)

context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"

if resource_klass.caching?

cache_ids = @resource_klasses[resource_klass].map do |(k, v)|

# Store the hashcode of the cache_field to avoid storing objects and to ensure precision isn't lost

# on timestamp types (i.e. string conversions dropping milliseconds)

[k, resource_klass.hash_cache_field(v[:cache_id])]

end

lookups.push(

CachedResponseFragment::Lookup.new(

resource_klass,

serializer_config_key,

context,

context_key,

cache_ids

)

)

else

@resource_klasses[resource_klass].keys.each do |k|

if @resource_klasses[resource_klass][k][:resource].nil?

missed_resource_ids[resource_klass] << k

else

register_resource(resource_klass, @resource_klasses[resource_klass][k][:resource])

end

end

end

end

if lookups.any?

raise "You've declared some Resources as caching without providing a caching store" if JSONAPI.configuration.resource_cache.nil?

# Step Two execute the cache lookup

found_resources = CachedResponseFragment.lookup(lookups, context)

else

found_resources = {}

end

# Step Three collect the results and collect hit/miss stats

stats = {}

found_resources.each do |resource_klass, resources|

resources.each do |id, cached_resource|

stats[resource_klass] ||= {}

if cached_resource.nil?

stats[resource_klass][:misses] ||= 0

stats[resource_klass][:misses] += 1

# Collect misses

missed_resource_ids[resource_klass].push(id)

else

stats[resource_klass][:hits] ||= 0

stats[resource_klass][:hits] += 1

register_resource(resource_klass, cached_resource)

end

end

end

report_stats(stats)

writes = []

# Step Four find any of the missing resources and join them into the result

missed_resource_ids.each_pair do |resource_klass, ids|

next if ids.empty?

find_opts = {context: context, fields: options[:fields]}

found_resources = resource_klass.find_to_populate_by_keys(ids, find_opts)

found_resources.each do |resource|

relationship_data = @resource_klasses[resource_klass][resource.id][:relationships]

if resource_klass.caching?

serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")

context_json = resource_klass.attribute_caching_context(context).to_json

context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)

context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"

writes.push(CachedResponseFragment::Write.new(

resource_klass,

resource,

serializer,

serializer_config_key,

context,

context_key,

relationship_data

))

end

register_resource(resource_klass, resource)

end

end

# Step Five conditionally write to the cache

CachedResponseFragment.write(writes) unless JSONAPI.configuration.resource_cache.nil?

mark_populated!

self

end

def mark_populated!

@populated = true

end

def register_resource(resource_klass, resource, primary = false)

@resource_klasses[resource_klass] ||= {}

@resource_klasses[resource_klass][resource.id] ||= {primary: resource.try(:primary) || primary, relationships: {}}

@resource_klasses[resource_klass][resource.id][:resource] = resource

end

private

def report_stats(stats)

return unless JSONAPI.configuration.resource_cache_usage_report_function || JSONAPI.configuration.resource_cache.nil?

stats.each_pair do |resource_klass, stat|

JSONAPI.configuration.resource_cache_usage_report_function.call(

resource_klass.name,

stat[:hits] || 0,

stat[:misses] || 0

)

end

end

def flatten_resource_tree(resource_tree, flattened_tree = {})

resource_tree.fragments.each_pair do |resource_rid, fragment|

resource_klass = resource_rid.resource_klass

id = resource_rid.id

flattened_tree[resource_klass] ||= {}

flattened_tree[resource_klass][id] ||= {primary: fragment.primary, relationships: {}}

flattened_tree[resource_klass][id][:cache_id] ||= fragment.cache if fragment.cache

flattened_tree[resource_klass][id][:resource] ||= fragment.resource if fragment.resource

fragment.related.try(:each_pair) do |relationship_name, related_rids|

flattened_tree[resource_klass][id][:relationships][relationship_name] ||= Set.new

flattened_tree[resource_klass][id][:relationships][relationship_name].merge(related_rids)

end

end

related_resource_trees = resource_tree.related_resource_trees

related_resource_trees.try(:each_value) do |related_resource_tree|

flatten_resource_tree(related_resource_tree, flattened_tree)

end

flattened_tree

end

end

end