fix(graphcache): Remove for-of syntax from Graphcache code for JSC memory reduction

.changeset/wet-buses-appear.md

@@ -0,0 +1,5 @@
+---
+'@urql/exchange-graphcache': patch
+---
+
+Remove `for-of` syntax from `@urql/exchange-graphcache` for JSC memory reduction

exchanges/graphcache/src/ast/traversal.ts

@@ -82,10 +82,10 @@ export const isDeferred = (
 ): boolean => {
   const { defer } = getDirectives(node);
   if (defer) {
-    for (const argument of defer.arguments || []) {
-      if (getName(argument) === 'if') {
+    for (let i = 0; defer.arguments && i < defer.arguments.length; i++) {
+      if (getName(defer.arguments[i]) === 'if') {
         // Return whether `@defer(if: )` is enabled
-        return !!valueFromASTUntyped(argument.value, vars);
+        return !!valueFromASTUntyped(defer.arguments[i].value, vars);
       }
     }
     return true;

exchanges/graphcache/src/cacheExchange.ts

@@ -92,8 +92,13 @@ export const cacheExchange =
     const isBlockedByOptimisticUpdate = (
       dependencies: Dependencies
     ): boolean => {
-      for (const dep of dependencies.values())
-        if (blockedDependencies.has(dep)) return true;
+      const depsIterator = dependencies[Symbol.iterator]();
+      for (
+        let depsEntry = depsIterator.next();
+        !depsEntry.done;
+        depsEntry = depsIterator.next()
+      )
+        if (blockedDependencies.has(depsEntry.value)) return true;
       return false;
     };
 
@@ -103,9 +108,22 @@ export const cacheExchange =
     ) => {
       if (dependencies) {
         // Collect operations that will be updated due to cache changes
-        for (const dep of dependencies.values()) {
-          const keys = deps.get(dep);
-          if (keys) for (const key of keys.values()) pendingOperations.add(key);
+        const depsIterator = dependencies[Symbol.iterator]();
+        for (
+          let depsEntry = depsIterator.next();
+          !depsEntry.done;
+          depsEntry = depsIterator.next()
+        ) {
+          const keys = deps.get(depsEntry.value);
+          if (keys) {
+            const keysIterator = keys[Symbol.iterator]();
+            for (
+              let keysEntry = keysIterator.next();
+              !keysEntry.done;
+              keysEntry = keysIterator.next()
+            )
+              pendingOperations.add(keysEntry.value);
+          }
         }
       }
     };
@@ -116,15 +134,21 @@ export const cacheExchange =
       isOptimistic: boolean
     ) => {
       // Reexecute collected operations and delete them from the mapping
-      for (const key of pendingOperations.values()) {
-        if (key !== operation.key) {
-          const op = operations.get(key);
+      const pendingIterator = pendingOperations[Symbol.iterator]();
+      for (
+        let pendingEntry = pendingIterator.next();
+        !pendingEntry.done;
+        pendingEntry = pendingIterator.next()
+      ) {
+        if (pendingEntry.value !== operation.key) {
+          const op = operations.get(pendingEntry.value);
           if (op) {
             // Collect all dependent operations if the reexecuting operation is a query
-            if (operation.kind === 'query') dependentOperations.add(key);
+            if (operation.kind === 'query')
+              dependentOperations.add(pendingEntry.value);
             let policy: RequestPolicy = 'cache-first';
-            if (requestedRefetch.has(key)) {
-              requestedRefetch.delete(key);
+            if (requestedRefetch.has(pendingEntry.value)) {
+              requestedRefetch.delete(pendingEntry.value);
               policy = 'cache-and-network';
             }
             client.reexecuteOperation(toRequestPolicy(op, policy));
@@ -175,7 +199,13 @@ export const cacheExchange =
         clearDataState();
         if (dependencies.size) {
           // Update blocked optimistic dependencies
-          for (const dep of dependencies.values()) blockedDependencies.add(dep);
+          const depsIterator = dependencies[Symbol.iterator]();
+          for (
+            let depsEntry = depsIterator.next();
+            !depsEntry.done;
+            depsEntry = depsIterator.next()
+          )
+            blockedDependencies.add(depsEntry.value);
           // Store optimistic dependencies for update
           optimisticKeysToDependencies.set(operation.key, dependencies);
           // Update related queries
@@ -205,9 +235,14 @@ export const cacheExchange =
 
     // This updates the known dependencies for the passed operation
     const updateDependencies = (op: Operation, dependencies: Dependencies) => {
-      for (const dep of dependencies.values()) {
-        let depOps = deps.get(dep);
-        if (!depOps) deps.set(dep, (depOps = new Set()));
+      const depsIterator = dependencies[Symbol.iterator]();
+      for (
+        let depsEntry = depsIterator.next();
+        !depsEntry.done;
+        depsEntry = depsIterator.next()
+      ) {
+        let depOps = deps.get(depsEntry.value);
+        if (!depOps) deps.set(depsEntry.value, (depOps = new Set()));
         depOps.add(op.key);
       }
     };

exchanges/graphcache/src/operations/invalidate.ts

@@ -30,8 +30,9 @@ export const invalidateType = (
   excludedEntities: string[]
 ) => {
   const types = InMemoryData.getEntitiesForType(typename);
-  for (const entity of types) {
-    if (excludedEntities.includes(entity)) continue;
-    invalidateEntity(entity);
+  const iterator = types[Symbol.iterator]();
+  for (let result = iterator.next(); !result.done; result = iterator.next()) {
+    if (excludedEntities.includes(result.value)) continue;
+    invalidateEntity(result.value);
   }
 };

exchanges/graphcache/src/store/data.ts

@@ -411,7 +411,14 @@ export const gc = () => {
   // Iterate over all entities that have been marked for deletion
   // Entities have been marked for deletion in `updateRCForEntity` if
   // their reference count dropped to 0
-  for (const entityKey of currentData!.gc.keys()) {
+  const gcIterator = currentData!.gc[Symbol.iterator]();
+  for (
+    let gcEntry = gcIterator.next();
+    !gcEntry.done;
+    gcEntry = gcIterator.next()
+  ) {
+    const entityKey = gcEntry.value;
+
     // Remove the current key from the GC batch
     currentData!.gc.delete(entityKey);
 
@@ -640,22 +647,30 @@ const squashLayer = (layerKey: number) => {
 
   const links = currentData!.links.optimistic.get(layerKey);
   if (links) {
-    for (const entry of links.entries()) {
-      const entityKey = entry[0];
-      const keyMap = entry[1];
+    const linksIterator = links[Symbol.iterator]();
+    for (
+      let linksEntry = linksIterator.next();
+      !linksEntry.done;
+      linksEntry = linksIterator.next()
+    ) {
+      const keyMap = linksEntry.value[1];
       for (const fieldKey in keyMap) {
-        writeLink(entityKey, fieldKey, keyMap[fieldKey]);
+        writeLink(linksEntry.value[0], fieldKey, keyMap[fieldKey]);
       }
     }
   }
 
   const records = currentData!.records.optimistic.get(layerKey);
   if (records) {
-    for (const entry of records.entries()) {
-      const entityKey = entry[0];
-      const keyMap = entry[1];
+    const recordsIterator = records[Symbol.iterator]();
+    for (
+      let recordsEntry = recordsIterator.next();
+      !recordsEntry.done;
+      recordsEntry = recordsIterator.next()
+    ) {
+      const keyMap = recordsEntry.value[1];
       for (const fieldKey in keyMap) {
-        writeRecord(entityKey, fieldKey, keyMap[fieldKey]);
+        writeRecord(recordsEntry.value[0], fieldKey, keyMap[fieldKey]);
       }
     }
   }
@@ -683,15 +698,20 @@ export const persistData = () => {
     currentOptimistic = true;
     currentOperation = 'read';
     const entries: SerializedEntries = {};
-    for (const key of currentData!.persist.keys()) {
-      const { entityKey, fieldKey } = deserializeKeyInfo(key);
+    const persistIterator = currentData!.persist[Symbol.iterator]();
+    for (
+      let persistEntry = persistIterator.next();
+      !persistEntry.done;
+      persistEntry = persistIterator.next()
+    ) {
+      const { entityKey, fieldKey } = deserializeKeyInfo(persistEntry.value);
       let x: void | Link | EntityField;
       if ((x = readLink(entityKey, fieldKey)) !== undefined) {
-        entries[key] = `:${stringifyVariables(x)}`;
+        entries[persistEntry.value] = `:${stringifyVariables(x)}`;
       } else if ((x = readRecord(entityKey, fieldKey)) !== undefined) {
-        entries[key] = stringifyVariables(x);
+        entries[persistEntry.value] = stringifyVariables(x);
       } else {
-        entries[key] = undefined;
+        entries[persistEntry.value] = undefined;
       }
     }