chore: do not save update metadata

The metadata returned is not valid and should not be stored for cache

internal/graph/cached_resolver.go

@@ -17,8 +17,9 @@ import (
 )
 
 const (
-	defaultMaxCacheSize = 10000
-	defaultCacheTTL     = 10 * time.Second
+	defaultMaxCacheSize     = 10000
+	defaultCacheTTL         = 10 * time.Second
+	defaultResolveNodeLimit = 25
 )
 
 var (
@@ -33,12 +34,34 @@ var (
 	})
 )
 
+// CachedResolveCheckResponse is very similar to ResolveCheckResponse except we
+// do not store the ResolutionData
+type CachedResolveCheckResponse struct {
+	Allowed bool
+}
+
+func (c *CachedResolveCheckResponse) convertToResolveCheckResponse() *ResolveCheckResponse {
+	return &ResolveCheckResponse{
+		Allowed: c.Allowed,
+		ResolutionMetadata: &ResolutionMetadata{
+			Depth:               defaultResolveNodeLimit,
+			DatastoreQueryCount: 0,
+		},
+	}
+}
+
+func newCachedResolveCheckResponse(r *ResolveCheckResponse) *CachedResolveCheckResponse {
+	return &CachedResolveCheckResponse{
+		Allowed: r.Allowed,
+	}
+}
+
 // CachedCheckResolver implements the CheckResolver interface in way that attempts to resolve
 // Check sub-problems via prior computations before delegating the request to some underlying
 // CheckResolver.
 type CachedCheckResolver struct {
 	delegate     CheckResolver
-	cache        *ccache.Cache[*ResolveCheckResponse]
+	cache        *ccache.Cache[*CachedResolveCheckResponse]
 	maxCacheSize int64
 	cacheTTL     time.Duration
 	logger       logger.Logger
@@ -66,7 +89,7 @@ func WithCacheTTL(ttl time.Duration) CachedCheckResolverOpt {
 }
 
 // WithExistingCache sets the cache to the provided cache
-func WithExistingCache(cache *ccache.Cache[*ResolveCheckResponse]) CachedCheckResolverOpt {
+func WithExistingCache(cache *ccache.Cache[*CachedResolveCheckResponse]) CachedCheckResolverOpt {
 	return func(ccr *CachedCheckResolver) {
 		ccr.cache = cache
 	}
@@ -83,6 +106,7 @@ func WithLogger(logger logger.Logger) CachedCheckResolverOpt {
 // but before delegating the query to the delegate a cache-key lookup is made to see if the Check sub-problem
 // has already recently been computed. If the Check sub-problem is in the cache, then the response is returned
 // immediately and no re-computation is necessary.
+// NOTE: the ResolveCheck's resolution data will be set as the default values as we actually did no database lookup
 func NewCachedCheckResolver(delegate CheckResolver, opts ...CachedCheckResolverOpt) *CachedCheckResolver {
 	checker := &CachedCheckResolver{
 		delegate:     delegate,
@@ -98,7 +122,7 @@ func NewCachedCheckResolver(delegate CheckResolver, opts ...CachedCheckResolverO
 	if checker.cache == nil {
 		// this means there were no cache supplied
 		checker.cache = ccache.New(
-			ccache.Configure[*ResolveCheckResponse]().MaxSize(checker.maxCacheSize),
+			ccache.Configure[*CachedResolveCheckResponse]().MaxSize(checker.maxCacheSize),
 		)
 	}
 
@@ -121,15 +145,15 @@ func (c *CachedCheckResolver) ResolveCheck(
 	cachedResp := c.cache.Get(cacheKey)
 	if cachedResp != nil && !cachedResp.Expired() {
 		checkCacheHitCounter.Inc()
-		return cachedResp.Value(), nil
+		return cachedResp.Value().convertToResolveCheckResponse(), nil
 	}
 
 	resp, err := c.delegate.ResolveCheck(ctx, req)
 	if err != nil {
 		return nil, err
 	}
 
-	c.cache.Set(cacheKey, resp, c.cacheTTL)
+	c.cache.Set(cacheKey, newCachedResolveCheckResponse(resp), c.cacheTTL)
 	return resp, nil
 }
 

internal/graph/cached_resolver_test.go

@@ -182,7 +182,7 @@ func TestResolveCheckFromCache(t *testing.T) {
 			test.setTestExpectations(newResolver, test.req)
 			dut2 := NewCachedCheckResolver(newResolver, WithExistingCache(dut.cache))
 			actualResult, err := dut2.ResolveCheck(ctx, test.req)
-			require.Equal(t, result, actualResult)
+			require.Equal(t, result.Allowed, actualResult.Allowed)
 			require.Nil(t, err)
 
 		})
@@ -211,13 +211,13 @@ func TestResolveCheckExpired(t *testing.T) {
 	// expect first call to result in actual resolve call
 	dut := NewCachedCheckResolver(initialMockResolver, WithCacheTTL(1*time.Microsecond))
 	actualResult, err := dut.ResolveCheck(ctx, req)
-	require.Equal(t, result, actualResult)
+	require.Equal(t, result.Allowed, actualResult.Allowed)
 	require.Equal(t, nil, err)
 
 	// subsequent call would have cache timeout and result in new ResolveCheck
 	time.Sleep(5 * time.Microsecond)
 
 	actualResult, err = dut.ResolveCheck(ctx, req)
-	require.Equal(t, result, actualResult)
+	require.Equal(t, result.Allowed, actualResult.Allowed)
 	require.Nil(t, err)
 }

internal/graph/check.go

@@ -410,14 +410,7 @@ func (c *LocalChecker) SetDelegate(delegate CheckResolver) {
 // was constructed with.
 func (c *LocalChecker) dispatch(ctx context.Context, req *ResolveCheckRequest) CheckHandlerFunc {
 	return func(ctx context.Context) (*ResolveCheckResponse, error) {
-		resp, err := c.delegate.ResolveCheck(ctx, req)
-		if err != nil {
-			return nil, err
-		}
-
-		return &ResolveCheckResponse{
-			Allowed: resp.Allowed,
-		}, nil
+		return c.delegate.ResolveCheck(ctx, req)
 	}
 }
 

pkg/server/commands/list_objects.go

@@ -61,7 +61,7 @@ type ListObjectsQuery struct {
 
 	// configurations for caching results
 	checkQueryCacheTTL time.Duration
-	checkCache         *ccache.Cache[*graph.ResolveCheckResponse] // checkCache has to be shared across requests
+	checkCache         *ccache.Cache[*graph.CachedResolveCheckResponse] // checkCache has to be shared across requests
 }
 
 type ListObjectsQueryOption func(d *ListObjectsQuery)
@@ -113,7 +113,7 @@ func WithCheckQueryCacheTTL(ttl time.Duration) ListObjectsQueryOption {
 }
 
 // WithCheckCache sets the cache used for resolve check results
-func WithCheckCache(checkCache *ccache.Cache[*graph.ResolveCheckResponse]) ListObjectsQueryOption {
+func WithCheckCache(checkCache *ccache.Cache[*graph.CachedResolveCheckResponse]) ListObjectsQueryOption {
 	return func(d *ListObjectsQuery) {
 		d.checkCache = checkCache
 	}

pkg/server/server.go

@@ -77,7 +77,7 @@ type Server struct {
 	checkQueryCacheEnabled bool
 	checkQueryCacheLimit   uint32
 	checkQueryCacheTTL     time.Duration
-	checkCache             *ccache.Cache[*graph.ResolveCheckResponse] // checkCache has to be shared across requests
+	checkCache             *ccache.Cache[*graph.CachedResolveCheckResponse] // checkCache has to be shared across requests
 }
 
 type OpenFGAServiceV1Option func(s *Server)
@@ -232,7 +232,7 @@ func NewServerWithOpts(opts ...OpenFGAServiceV1Option) (*Server, error) {
 
 	if slices.Contains(s.experimentals, ExperimentalCheckQueryCache) && s.checkQueryCacheEnabled {
 		s.checkCache = ccache.New(
-			ccache.Configure[*graph.ResolveCheckResponse]().MaxSize(int64(s.checkQueryCacheLimit)),
+			ccache.Configure[*graph.CachedResolveCheckResponse]().MaxSize(int64(s.checkQueryCacheLimit)),
 		)
 	}
 

pkg/server/test/list_objects.go

@@ -238,7 +238,7 @@ func TestListObjectsRespectsMaxResults(t *testing.T, ds storage.OpenFGADatastore
 
 			if test.useCheckCache {
 				checkCache := ccache.New(
-					ccache.Configure[*graph.ResolveCheckResponse]().MaxSize(100),
+					ccache.Configure[*graph.CachedResolveCheckResponse]().MaxSize(100),
 				)
 				opts = append(opts,
 					commands.WithCheckCache(checkCache),