apollo-invalidation-policies - npm Package Compare versions

Comparing version 1.0.0-beta5 to 1.0.0-beta7

CHANGELOG.md

@@ -1,3 +0,13 @@
-1.0.0.-beta5 (Dan Reynolds)
 
+1.0.0-beta7 (Dan Reynolds)
+
+- Fix issue where read policies were attempted to be evaluated for non-normalized entities not yet in the cache if they had a different store field name with the same name
+  already written in the cache.
+
+1.0.0-beta6 (Dan Reynolds)
+
+- Adds a `storage` dictionary by unique `storeFieldName` for queries or `ID` for normalized entities in the policy action object so that arbitrary meta information can be stored across multiple policy action invocations.
+
+1.0.0-beta5 (Dan Reynolds)
+
 - Adds support for a `renewalPolicy` type and global config option for specifying how type TTLs should be renewed on write vs access
@@ -4,0 +14,0 @@ - Adds the `expire` API for evicting all entities that have expired in the cache based on their type's or the global TTL.

dist/policies/InvalidationPolicyManager.d.ts

@@ -10,5 +10,7 @@ import { InvalidationPolicyEvent, InvalidationPolicyManagerConfig, PolicyActionMeta } from "./types";
     private policyActivation;
+    private policyActionStorage;
     constructor(config: InvalidationPolicyManagerConfig);
     private activatePolicies;
     private getPolicy;
+    private getPolicyActionStorage;
     private getTypePolicyForEvent;
@@ -15,0 +17,0 @@ private runPolicyEvent;

dist/policies/InvalidationPolicyManager.js

@@ -17,2 +17,3 @@ "use strict";
         this.config = config;
+        this.policyActionStorage = {};
         const { cacheOperations: { readField, evict, modify }, } = this.config;
@@ -52,2 +53,9 @@ // Watch broadcasts by evict and modify operations called by policy actions
     }
+    getPolicyActionStorage(identifier) {
+        const existingStorage = this.policyActionStorage[identifier];
+        if (!existingStorage) {
+            this.policyActionStorage[identifier] = {};
+        }
+        return this.policyActionStorage[identifier];
+    }
     getTypePolicyForEvent(typeName, policyEvent) {
@@ -76,7 +84,7 @@ const policyForType = this.getPolicy(typeName);
                         policyAction(mutedCacheOperations, Object.assign({ id: dataId, fieldName,
-                            storeFieldName, variables: storeFieldNames.entries[storeFieldName].variables, ref: client_1.makeReference(dataId) }, policyMeta));
+                            storeFieldName, variables: storeFieldNames.entries[storeFieldName].variables, ref: client_1.makeReference(dataId), storage: this.getPolicyActionStorage(storeFieldName) }, policyMeta));
                     });
                 }
                 else {
-                    policyAction(mutedCacheOperations, Object.assign({ id: dataId, ref: client_1.makeReference(dataId) }, policyMeta));
+                    policyAction(mutedCacheOperations, Object.assign({ id: dataId, storage: this.getPolicyActionStorage(dataId), ref: client_1.makeReference(dataId) }, policyMeta));
                 }
@@ -105,5 +113,17 @@ });
         }
-        const entityCacheTime = storeFieldName && typeMapEntity.storeFieldNames
-            ? typeMapEntity.storeFieldNames.entries[storeFieldName].cacheTime
-            : typeMapEntity.cacheTime;
+        let entityCacheTime;
+        // If a read is done against an entity before it has ever been written, it would not be present in the cache yet and should not attempt
+        // to have read policy eviction run on it. This can occur in the case of fetching a query field over the network for example, where first
+        // before it has come back from the network, the Apollo Client tries to diff it against the store to see what the existing value is for it,
+        // but on first fetch it would not exist.
+        if (storeFieldName && !!typeMapEntity.storeFieldNames) {
+            const entityForStoreFieldName = typeMapEntity.storeFieldNames.entries[storeFieldName];
+            if (!entityForStoreFieldName) {
+                return true;
+            }
+            entityCacheTime = entityForStoreFieldName.cacheTime;
+        }
+        else {
+            entityCacheTime = typeMapEntity.cacheTime;
+        }
         const timeToLive = ((_a = this.getPolicy(typename)) === null || _a === void 0 ? void 0 : _a.timeToLive) || policies.timeToLive;
@@ -110,0 +130,0 @@ if (lodash_1.default.isNumber(entityCacheTime) &&

dist/policies/types.d.ts

@@ -26,2 +26,3 @@ import { Cache, Reference, StoreObject, StoreValue } from "@apollo/client";
 }
+export declare type PolicyActionStorage = Record<string, Record<string, any>>;
 export interface PolicyActionFields {
@@ -32,2 +33,3 @@ id: string;
     storeFieldName?: string;
+    storage: PolicyActionStorage;
     variables?: Record<string, any>;
@@ -37,3 +39,3 @@ }
 export interface PolicyActionMeta {
-    parent: PolicyActionFields;
+    parent: Omit<PolicyActionFields, 'storage'>;
 }
@@ -40,0 +42,0 @@ export declare type PolicyAction = (cacheOperations: PolicyActionCacheOperations, entity: PolicyActionEntity) => void;

package.json

 {
   "name": "apollo-invalidation-policies",
-  "version": "1.0.0-beta5",
+  "version": "1.0.0-beta7",
   "description": "An extension to the InMemoryCache from Apollo for type-based invalidation policies.",
@@ -30,3 +30,3 @@ "main": "dist/index.js",
   "peerDependencies": {
-    "@apollo/client": "^3.0.0"
+    "@apollo/client": "^3.3.0"
   },
@@ -43,3 +43,3 @@ "dependencies": {
   "devDependencies": {
-    "@apollo/client": "^3.2.0",
+    "@apollo/client": "^3.3.0",
     "@types/jest": "^25.1.5",
@@ -46,0 +46,0 @@ "jest": "^25.2.6",

README.md

@@ -64,9 +64,10 @@ ![Build](https://github.com/NerdWalletOSS/apollo-invalidation-policies/workflows/Build/badge.svg)
 | Policy Action Entity | Description                                             | Type               | Example                                                                                     |
-| ---------------------| --------------------------------------------------------|--------------------| --------------------------------------------------------------------------------------------|
-| `id`                 | The id of the entity in the Apollo cache                | string             | `Employee:1`, `ROOT_QUERY`                                                                  |
-| `ref`                | The reference object for the entity in the Apollo cache | Reference          | `{ __ref: 'Employee:1' }`, `{ __ref: 'ROOT_QUERY' }`                                        |
-| `fieldName`          | The field for the entity in the Apollo cache            | string?            | `employees`                                                                                 |
-| `storeFieldName`     | The `fieldName` combined with its distinct variables    | string?            | `employees({ location: 'US' })`                                                             |
-| `variables`          | The variables the entity was written with               | Object?            | `{ location: 'US' }`                                                                        |
-| `parent`             | The parent entity that triggered the PolicyEvent        | PolicyActionEntity | `{ id: 'ROOT_QUERY', fieldName: 'deleteEmployees', storeFieldName: 'deleteEmployees({}), ref: { __ref: 'ROOT_QUERY' }, variables: {} }'` |
+| ---------------------| --------------------------------------------------------|--------------------| ---------------------------------------------------------------------------------------------|
+| `id`                 | The id of the entity in the Apollo cache                | string              | `Employee:1`, `ROOT_QUERY`                                                                  |
+| `ref`                | The reference object for the entity in the Apollo cache | Reference           | `{ __ref: 'Employee:1' }`, `{ __ref: 'ROOT_QUERY' }`                                        |
+| `fieldName`          | The field for the entity in the Apollo cache            | string?             | `employees`                                                                                 |
+| `storeFieldName`     | The `fieldName` combined with its distinct variables    | string?             | `employees({ location: 'US' })`                                                             |
+| `variables`          | The variables the entity was written with               | Object?             | `{ location: 'US' }`                                                                        |
+| `storage`            | An object for storing unique entity metadata across policy action invocations | Object            | `{}`                                                                        |
+| `parent`             | The parent entity that triggered the PolicyEvent        | PolicyActionEntity  | `{ id: 'ROOT_QUERY', fieldName: 'deleteEmployees', storeFieldName: 'deleteEmployees({}), ref: { __ref: 'ROOT_QUERY' }, variables: {} }'` |
 
@@ -73,0 +74,0 @@ ```javascript

No alert changes

Improved metrics

Total package byte prevSize

560101

0.42%

Lines of code

1537

1.59%

Number of lines in readme file

276

0.36%

No dependency changes