jazz-tools 0.19.11 → 0.19.12

package/src/inspector/viewer/history-view.tsx

@@ -128,7 +128,7 @@ function mapTransactionToAction(
   coValue: RawCoValue,
 ): string {
   // Group changes
-  if (TransactionChanges.isUserPromotion(change)) {
+  if (TransactionChanges.isUserPromotion(coValue, change)) {
     if (change.value === "revoked") {
       return `${change.key} has been revoked`;
     }
@@ -136,28 +136,28 @@ function mapTransactionToAction(
     return `${change.key} has been promoted to ${change.value}`;
   }
 
-  if (TransactionChanges.isGroupExtension(change)) {
+  if (TransactionChanges.isGroupExtension(coValue, change)) {
     const child = change.key.slice(6);
     return `Group became a member of ${child}`;
   }
 
-  if (TransactionChanges.isGroupExtendRevocation(change)) {
+  if (TransactionChanges.isGroupExtendRevocation(coValue, change)) {
     const child = change.key.slice(6);
     return `Group's membership of ${child} has been revoked.`;
   }
 
-  if (TransactionChanges.isGroupPromotion(change)) {
+  if (TransactionChanges.isGroupPromotion(coValue, change)) {
     const parent = change.key.slice(7);
     return `Group ${parent} has been promoted to ${change.value}`;
   }
 
-  if (TransactionChanges.isKeyRevelation(change)) {
+  if (TransactionChanges.isKeyRevelation(coValue, change)) {
     const [key, target] = change.key.split("_for_");
     return `Key "${key}" has been revealed to "${target}"`;
   }
 
   // coList changes
-  if (TransactionChanges.isItemAppend(change)) {
+  if (TransactionChanges.isItemAppend(coValue, change)) {
     if (change.after === "start") {
       return `"${change.value}" has been appended`;
     }
@@ -171,7 +171,7 @@ function mapTransactionToAction(
     return `"${change.value}" has been inserted after "${(after as any).value}"`;
   }
 
-  if (TransactionChanges.isItemPrepend(change)) {
+  if (TransactionChanges.isItemPrepend(coValue, change)) {
     if (change.before === "end") {
       return `"${change.value}" has been prepended`;
     }
@@ -185,7 +185,7 @@ function mapTransactionToAction(
     return `"${change.value}" has been inserted before "${(before as any).value}"`;
   }
 
-  if (TransactionChanges.isItemDeletion(change)) {
+  if (TransactionChanges.isItemDeletion(coValue, change)) {
     const insertion = findListChange(change.insertion, coValue);
     if (insertion === undefined) {
       return `An undefined item has been deleted`;
@@ -195,24 +195,24 @@ function mapTransactionToAction(
   }
 
   // coStream changes
-  if (TransactionChanges.isStreamStart(change)) {
+  if (TransactionChanges.isStreamStart(coValue, change)) {
     return `Stream started with mime type "${change.mimeType}" and file name "${change.fileName}"`;
   }
 
-  if (TransactionChanges.isStreamChunk(change)) {
+  if (TransactionChanges.isStreamChunk(coValue, change)) {
     return `Stream chunk added`;
   }
 
-  if (TransactionChanges.isStreamEnd(change)) {
+  if (TransactionChanges.isStreamEnd(coValue, change)) {
     return `Stream ended`;
   }
 
   // coMap changes
-  if (TransactionChanges.isPropertySet(change)) {
+  if (TransactionChanges.isPropertySet(coValue, change)) {
     return `Property "${change.key}" has been set to ${JSON.stringify(change.value)}`;
   }
 
-  if (TransactionChanges.isPropertyDeletion(change)) {
+  if (TransactionChanges.isPropertyDeletion(coValue, change)) {
     return `Property "${change.key}" has been deleted`;
   }
 

package/src/react/provider.tsx

@@ -58,6 +58,9 @@ export function JazzReactProvider<
   );
   const logoutReplacementActiveRef = useRef(false);
   logoutReplacementActiveRef.current = Boolean(logOutReplacement);
+  const onAnonymousAccountDiscardedEnabled = Boolean(
+    onAnonymousAccountDiscarded,
+  );
 
   const value = React.useSyncExternalStore<
     JazzContextType<InstanceOfSchema<S>> | undefined
@@ -74,7 +77,9 @@ export function JazzReactProvider<
           logOutReplacement: logoutReplacementActiveRef.current
             ? logOutReplacementRefCallback
             : undefined,
-          onAnonymousAccountDiscarded: onAnonymousAccountDiscardedRefCallback,
+          onAnonymousAccountDiscarded: onAnonymousAccountDiscardedEnabled
+            ? onAnonymousAccountDiscardedRefCallback
+            : undefined,
         } satisfies JazzContextManagerProps<S>;
 
         if (contextManager.propsChanged(props)) {

package/src/react-core/hooks.ts

@@ -489,7 +489,7 @@ export function useSuspenseCoState<
     throw new Error("Subscription not found");
   }
 
-  use(subscription.getPromise());
+  use(subscription.getCachedPromise());
 
   const getCurrentValue = () => {
     const value = subscription.getCurrentValue();
@@ -824,7 +824,7 @@ export function useSuspenseAccount<
     );
   }
 
-  use(subscription.getPromise());
+  use(subscription.getCachedPromise());
 
   const getCurrentValue = () => {
     const value = subscription.getCurrentValue();

package/src/react-core/tests/useSuspenseCoState.test.tsx

@@ -370,6 +370,53 @@ describe("useSuspenseCoState", () => {
     });
   });
 
+  it("should throw error when CoValue becomes unauthorized", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+    });
+
+    const group = Group.create();
+    group.addMember("everyone", "reader");
+
+    // Create CoValue owned by another account without sharing
+    const map = TestMap.create(
+      {
+        value: "123",
+      },
+      group,
+    );
+
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const TestComponent = () => {
+      const value = useSuspenseCoState(TestMap, map.$jazz.id);
+      return <div>{value.value}</div>;
+    };
+
+    const { container } = await act(async () => {
+      return render(
+        <ErrorBoundary fallback={<div>Error!</div>}>
+          <Suspense fallback={<div>Loading...</div>}>
+            <TestComponent />
+          </Suspense>
+        </ErrorBoundary>,
+      );
+    });
+    await waitFor(() => {
+      expect(container.textContent).toContain("123");
+      expect(container.textContent).not.toContain("Loading...");
+    });
+
+    group.removeMember("everyone");
+
+    // Wait for error to be thrown (unauthorized access)
+    await waitFor(() => {
+      expect(container.textContent).toContain("Error!");
+    });
+  });
+
   it("should update value when CoValue changes", async () => {
     const TestMap = co.map({
       value: z.string(),

package/src/react-native-core/provider.tsx

@@ -55,6 +55,9 @@ export function JazzProviderCore<
   );
   const logoutReplacementActiveRef = useRef(false);
   logoutReplacementActiveRef.current = Boolean(logOutReplacement);
+  const onAnonymousAccountDiscardedEnabled = Boolean(
+    onAnonymousAccountDiscarded,
+  );
 
   const value = React.useSyncExternalStore<
     JazzContextType<InstanceOfSchema<S>> | undefined
@@ -71,7 +74,9 @@ export function JazzProviderCore<
           logOutReplacement: logoutReplacementActiveRef.current
             ? logOutReplacementRefCallback
             : undefined,
-          onAnonymousAccountDiscarded: onAnonymousAccountDiscardedRefCallback,
+          onAnonymousAccountDiscarded: onAnonymousAccountDiscardedEnabled
+            ? onAnonymousAccountDiscardedRefCallback
+            : undefined,
           CryptoProvider,
         } satisfies JazzContextManagerProps<S>;
 

package/src/tools/implementation/ContextManager.ts

@@ -351,6 +351,16 @@ export class JazzContextManager<
       // The storage is reachable through currentContext using the connectedPeers
       prevContext.node.removeStorage();
 
+      // Ensure that the new context is the only peer connected to the previous context
+      // This way all the changes made in the previous context are synced only to the new context
+      for (const peer of Object.values(prevContext.node.syncManager.peers)) {
+        if (!peer.closed) {
+          peer.gracefulShutdown();
+        }
+      }
+
+      prevContext.node.syncManager.peers = {};
+
       currentContext.node.syncManager.addPeer(prevAccountAsPeer);
       prevContext.node.syncManager.addPeer(currentAccountAsPeer);
 

package/src/tools/subscribe/SubscriptionScope.ts

@@ -309,64 +309,86 @@ export class SubscriptionScope<D extends CoValue> {
 
   unloadedValue: NotLoaded<D> | undefined;
 
-  lastPromise:
-    | {
-        value: MaybeLoaded<D> | undefined;
-        promise: PromiseWithStatus<MaybeLoaded<D>>;
-      }
-    | undefined;
-
-  cachePromise(value: MaybeLoaded<D>, callback: () => PromiseWithStatus<D>) {
-    if (this.lastPromise?.value === value) {
-      return this.lastPromise.promise;
-    }
-
-    const promise = callback();
-    this.lastPromise = { value, promise };
-
-    return promise;
-  }
+  lastPromise: PromiseWithStatus<D> | undefined;
 
   getPromise() {
     const currentValue = this.getCurrentValue();
 
     if (currentValue.$isLoaded) {
-      return resolvedPromise(currentValue);
+      return resolvedPromise<D>(currentValue);
     }
 
     if (currentValue.$jazz.loadingState !== CoValueLoadingState.LOADING) {
       const error = this.getError();
-      return rejectedPromise(
+      return rejectedPromise<D>(
         new Error(error?.toString() ?? "Unknown error", {
           cause: this.callerStack,
         }),
       );
     }
 
-    // We need to cache rejected promises to make React Suspense happy
-    return this.cachePromise(currentValue, () => {
-      return new Promise<D>((resolve, reject) => {
-        const unsubscribe = this.subscribe(() => {
-          const currentValue = this.getCurrentValue();
+    const promise = new Promise<D>((resolve, reject) => {
+      const unsubscribe = this.subscribe(() => {
+        const currentValue = this.getCurrentValue();
 
-          if (currentValue.$jazz.loadingState === CoValueLoadingState.LOADING) {
-            return;
-          }
+        if (currentValue.$jazz.loadingState === CoValueLoadingState.LOADING) {
+          return;
+        }
 
-          if (currentValue.$isLoaded) {
-            resolve(currentValue);
-          } else {
-            reject(
-              new Error(this.getError()?.toString() ?? "Unknown error", {
-                cause: this.callerStack,
-              }),
-            );
-          }
+        if (currentValue.$isLoaded) {
+          promise.status = "fulfilled";
+          promise.value = currentValue;
+          resolve(currentValue);
+        } else {
+          promise.status = "rejected";
+          promise.reason = new Error(
+            this.getError()?.toString() ?? "Unknown error",
+            {
+              cause: this.callerStack,
+            },
+          );
+          reject(
+            new Error(this.getError()?.toString() ?? "Unknown error", {
+              cause: this.callerStack,
+            }),
+          );
+        }
 
-          unsubscribe();
-        });
+        unsubscribe();
       });
-    });
+    }) as PromiseWithStatus<D>;
+
+    promise.status = "pending";
+
+    return promise;
+  }
+
+  getCachedPromise() {
+    if (this.lastPromise) {
+      const value = this.getCurrentValue();
+
+      // if the value is loaded, we update the promise state
+      // to ensure that the value provided is always up to date
+      if (value.$isLoaded) {
+        this.lastPromise.status = "fulfilled";
+        this.lastPromise.value = value;
+      } else if (value.$jazz.loadingState !== CoValueLoadingState.LOADING) {
+        this.lastPromise.status = "rejected";
+        this.lastPromise.reason = new Error(
+          this.getError()?.toString() ?? "Unknown error",
+          {
+            cause: this.callerStack,
+          },
+        );
+      } else if (this.lastPromise.status !== "pending") {
+        // Value got into loading state, we need to suspend again
+        this.lastPromise = this.getPromise();
+      }
+    } else {
+      this.lastPromise = this.getPromise();
+    }
+
+    return this.lastPromise;
   }
 
   private getUnloadedValue(reason: NotLoadedCoValueState): NotLoaded<D> {