jazz-tools 0.19.11 → 0.19.13

package/src/inspector/utils/history.ts

@@ -62,10 +62,10 @@ export function getTransactionChanges(
     const firstChange = tx.changes[0]!;
 
     if (
-      TransactionChanges.isItemAppend(firstChange) &&
+      TransactionChanges.isItemAppend(coValue, firstChange) &&
       tx.changes.every(
         (c) =>
-          TransactionChanges.isItemAppend(c) &&
+          TransactionChanges.isItemAppend(coValue, c) &&
           areSameOpIds(c.after, firstChange.after),
       )
     ) {
@@ -84,10 +84,10 @@ export function getTransactionChanges(
     }
 
     if (
-      TransactionChanges.isItemPrepend(firstChange) &&
+      TransactionChanges.isItemPrepend(coValue, firstChange) &&
       tx.changes.every(
         (c) =>
-          TransactionChanges.isItemPrepend(c) &&
+          TransactionChanges.isItemPrepend(coValue, c) &&
           areSameOpIds(c.before, firstChange.before),
       )
     ) {
@@ -106,8 +106,8 @@ export function getTransactionChanges(
     }
 
     if (
-      TransactionChanges.isItemDeletion(firstChange) &&
-      tx.changes.every((c) => TransactionChanges.isItemDeletion(c))
+      TransactionChanges.isItemDeletion(coValue, firstChange) &&
+      tx.changes.every((c) => TransactionChanges.isItemDeletion(coValue, c))
     ) {
       const coValueBeforeDeletions = coValue.atTime(tx.madeAt - 1);
 

package/src/inspector/utils/transactions-changes.ts

@@ -14,85 +14,119 @@ import type {
 import { isCoId } from "../viewer/types";
 
 export const isGroupExtension = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<
   MapOpPayload<`child_${string}`, "extend">,
   { op: "set" }
 > => {
+  if (coValue.core.isGroup() === false) return false;
   return change?.op === "set" && change?.value === "extend";
 };
 
 export const isGroupExtendRevocation = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<
   MapOpPayload<`child_${string}`, "revoked">,
   { op: "set" }
 > => {
+  if (coValue.core.isGroup() === false) return false;
   return change?.op === "set" && change?.value === "revoked";
 };
 
 export const isGroupPromotion = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<
   MapOpPayload<`parent_co_${string}`, AccountRole>,
   { op: "set" }
 > => {
+  if (coValue.core.isGroup() === false) return false;
   return change?.op === "set" && change?.key.startsWith("parent_co_");
 };
 
 export const isUserPromotion = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<MapOpPayload<CoID<RawCoValue>, Role>, { op: "set" }> => {
+  if (coValue.core.isGroup() === false) return false;
   return (
     change?.op === "set" && (isCoId(change?.key) || change?.key === "everyone")
   );
 };
 
 export const isKeyRevelation = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<
   MapOpPayload<`${string}_for_${string}`, string>,
   { op: "set" }
 > => {
+  if (
+    coValue.core.isGroup() === false &&
+    coValue.headerMeta?.type !== "account"
+  )
+    return false;
   return change?.op === "set" && change?.key.includes("_for_");
 };
 
 export const isPropertySet = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<MapOpPayload<string, any>, { op: "set" }> => {
   return change?.op === "set" && "key" in change && "value" in change;
 };
 export const isPropertyDeletion = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<MapOpPayload<string, any>, { op: "del" }> => {
   return change?.op === "del" && "key" in change;
 };
 
 export const isItemAppend = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<ListOpPayload<any>, { op: "app" }> => {
+  if (coValue.type !== "colist" && coValue.type !== "coplaintext") return false;
   return change?.op === "app" && "after" in change && "value" in change;
 };
 export const isItemPrepend = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<ListOpPayload<any>, { op: "pre" }> => {
+  if (coValue.type !== "colist" && coValue.type !== "coplaintext") return false;
   return change?.op === "pre" && "before" in change && "value" in change;
 };
 
 export const isItemDeletion = (
+  coValue: RawCoValue,
   change: any,
 ): change is Extract<ListOpPayload<any>, { op: "del" }> => {
+  if (coValue.type !== "colist" && coValue.type !== "coplaintext") return false;
   return change?.op === "del" && "insertion" in change;
 };
 
-export const isStreamStart = (change: any): change is BinaryStreamStart => {
+export const isStreamStart = (
+  coValue: RawCoValue,
+  change: any,
+): change is BinaryStreamStart => {
+  if (coValue.type !== "coStream") return false;
   return change?.type === "start" && "mimeType" in change;
 };
 
-export const isStreamChunk = (change: any): change is BinaryStreamChunk => {
+export const isStreamChunk = (
+  coValue: RawCoValue,
+  change: any,
+): change is BinaryStreamChunk => {
+  if (coValue.type !== "coStream") return false;
   return change?.type === "chunk" && "chunk" in change;
 };
 
-export const isStreamEnd = (change: any): change is BinaryStreamEnd => {
+export const isStreamEnd = (
+  coValue: RawCoValue,
+  change: any,
+): change is BinaryStreamEnd => {
+  if (coValue.type !== "coStream") return false;
   return change?.type === "end";
 };

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/ReactNativeSessionProvider.ts

@@ -0,0 +1,52 @@
+import {
+  CryptoProvider,
+  KvStoreContext,
+  SessionID,
+  SessionProvider,
+} from "jazz-tools";
+import { AgentID, RawAccountID } from "cojson";
+
+export class ReactNativeSessionProvider implements SessionProvider {
+  async acquireSession(
+    accountID: string,
+    crypto: CryptoProvider,
+  ): Promise<{ sessionID: SessionID; sessionDone: () => void }> {
+    const kvStore = KvStoreContext.getInstance().getStorage();
+    const existingSession = await kvStore.get(accountID as string);
+
+    if (existingSession) {
+      console.log("Using existing session", existingSession);
+      return Promise.resolve({
+        sessionID: existingSession as SessionID,
+        sessionDone: () => {},
+      });
+    }
+
+    // We need to provide this for backwards compatibility with the old session provider
+    // With the current session provider we should never get here because:
+    // - New accounts provide their session and go through the persistSession method
+    // - Existing accounts should already have a session
+    const newSessionID = crypto.newRandomSessionID(
+      accountID as RawAccountID | AgentID,
+    );
+    await kvStore.set(accountID, newSessionID);
+
+    console.error("Created new session", newSessionID);
+
+    return Promise.resolve({
+      sessionID: newSessionID,
+      sessionDone: () => {},
+    });
+  }
+
+  async persistSession(
+    accountID: string,
+    sessionID: SessionID,
+  ): Promise<{ sessionDone: () => void }> {
+    const kvStore = KvStoreContext.getInstance().getStorage();
+    await kvStore.set(accountID, sessionID);
+    return Promise.resolve({
+      sessionDone: () => {},
+    });
+  }
+}

package/src/react-native-core/platform.ts

@@ -1,25 +1,22 @@
 import NetInfo from "@react-native-community/netinfo";
-import { LocalNode, Peer, RawAccountID, getSqliteStorageAsync } from "cojson";
+import { LocalNode, Peer, getSqliteStorageAsync } from "cojson";
 import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto"; // Importing from dist to not rely on the exports field
 import {
   Account,
   AccountClass,
-  AgentID,
   AnyAccountSchema,
   AuthCredentials,
   AuthSecretStorage,
   CoValue,
   CoValueFromRaw,
-  CryptoProvider,
-  ID,
   NewAccountProps,
-  SessionID,
   SyncConfig,
   createInviteLink as baseCreateInviteLink,
   createAnonymousJazzContext,
   createJazzContext,
 } from "jazz-tools";
 import { KvStore, KvStoreContext } from "./storage/kv-store-context.js";
+import { ReactNativeSessionProvider } from "./ReactNativeSessionProvider.js";
 
 import { SQLiteDatabaseDriverAsync } from "cojson";
 import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
@@ -200,6 +197,8 @@ export async function createJazzReactNativeContext<
     handleAuthUpdate(authSecretStorage.isAuthenticated);
   }
 
+  const sessionProvider = new ReactNativeSessionProvider();
+
   const context = await createJazzContext({
     credentials: options.credentials,
     newAccountProps: options.newAccountProps,
@@ -207,7 +206,7 @@ export async function createJazzReactNativeContext<
     crypto,
     defaultProfileName: options.defaultProfileName,
     AccountSchema: options.AccountSchema,
-    sessionProvider: provideLockSession,
+    sessionProvider,
     authSecretStorage: options.authSecretStorage,
     storage,
   });
@@ -233,30 +232,6 @@ export async function createJazzReactNativeContext<
   };
 }
 
-/** @category Auth Providers */
-export type SessionProvider = (
-  accountID: ID<Account> | AgentID,
-) => Promise<SessionID>;
-
-export async function provideLockSession(
-  accountID: ID<Account> | AgentID,
-  crypto: CryptoProvider,
-) {
-  const sessionDone = () => {};
-
-  const kvStore = KvStoreContext.getInstance().getStorage();
-
-  const sessionID =
-    ((await kvStore.get(accountID)) as SessionID) ||
-    crypto.newRandomSessionID(accountID as RawAccountID | AgentID);
-  await kvStore.set(accountID, sessionID);
-
-  return Promise.resolve({
-    sessionID,
-    sessionDone,
-  });
-}
-
 /** @category Invite Links */
 export function createInviteLink<C extends CoValue>(
   value: C,

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/react-native-core/tests/ReactNativeSessionProvider.test.ts

@@ -0,0 +1,124 @@
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { SessionID } from "cojson";
+import { beforeEach, describe, expect, test } from "vitest";
+import { InMemoryKVStore } from "jazz-tools";
+import { KvStoreContext, type KvStore } from "jazz-tools";
+import { ReactNativeSessionProvider } from "../ReactNativeSessionProvider.js";
+import { createJazzTestAccount } from "jazz-tools/testing";
+import type { CryptoProvider } from "jazz-tools";
+
+// Initialize KV store for tests
+const kvStore = new InMemoryKVStore() as KvStore;
+KvStoreContext.getInstance().initialize(kvStore);
+
+const Crypto = await WasmCrypto.create();
+
+describe("ReactNativeSessionProvider", () => {
+  let sessionProvider: ReactNativeSessionProvider;
+  let account: Awaited<ReturnType<typeof createJazzTestAccount>>;
+
+  beforeEach(async () => {
+    // Clear KV store
+    kvStore.clearAll();
+
+    // Create new session provider instance
+    sessionProvider = new ReactNativeSessionProvider();
+
+    // Create test account
+    account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+  });
+
+  describe("acquireSession", () => {
+    test("creates new session when none exists", async () => {
+      const accountID = account.$jazz.id;
+
+      // Verify no session exists
+      const existingSessionBefore = await kvStore.get(accountID);
+      expect(existingSessionBefore).toBeNull();
+
+      // Acquire session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify a new session ID is generated
+      expect(result.sessionID).toBeDefined();
+
+      // Verify the session is stored in KvStore
+      const storedSession = await kvStore.get(accountID);
+      expect(storedSession).toBeDefined();
+      expect(storedSession).toBe(result.sessionID);
+    });
+
+    test("returns existing session when one exists", async () => {
+      const accountID = account.$jazz.id;
+      const existingSessionID = "existing-session-id" as SessionID;
+
+      // Pre-populate KvStore with a session ID
+      await kvStore.set(accountID, existingSessionID);
+
+      // Verify session exists before calling acquireSession
+      const sessionBefore = await kvStore.get(accountID);
+      expect(sessionBefore).toBe(existingSessionID);
+
+      // Acquire session
+      const result = await sessionProvider.acquireSession(
+        accountID,
+        Crypto as CryptoProvider,
+      );
+
+      // Verify the existing session ID is returned (not a new one)
+      expect(result.sessionID).toBe(existingSessionID);
+
+      // Verify no new session is created (same value still in store)
+      const sessionAfter = await kvStore.get(accountID);
+      expect(sessionAfter).toBe(existingSessionID);
+      expect(sessionAfter).toBe(result.sessionID);
+    });
+  });
+
+  describe("persistSession", () => {
+    test("stores session ID correctly", async () => {
+      const accountID = account.$jazz.id;
+      const sessionID = "test-session-id" as SessionID;
+
+      // Verify no session exists before
+      const sessionBefore = await kvStore.get(accountID);
+      expect(sessionBefore).toBeNull();
+
+      // Persist session
+      await sessionProvider.persistSession(accountID, sessionID);
+
+      // Verify the session ID is stored in KvStore
+      const storedSession = await kvStore.get(accountID);
+      expect(storedSession).toBeDefined();
+
+      // Verify the stored value matches the provided session ID
+      expect(storedSession).toBe(sessionID);
+    });
+
+    test("overwrites existing session", async () => {
+      const accountID = account.$jazz.id;
+      const initialSessionID = "initial-session-id" as SessionID;
+      const newSessionID = "new-session-id" as SessionID;
+
+      // Store an initial session ID
+      await kvStore.set(accountID, initialSessionID);
+
+      // Verify initial session is stored
+      const sessionBefore = await kvStore.get(accountID);
+      expect(sessionBefore).toBe(initialSessionID);
+
+      // Persist a different session ID
+      await sessionProvider.persistSession(accountID, newSessionID);
+
+      // Verify the new session ID replaces the old one
+      const sessionAfter = await kvStore.get(accountID);
+      expect(sessionAfter).toBe(newSessionID);
+      expect(sessionAfter).not.toBe(initialSessionID);
+    });
+  });
+});

package/src/tools/coValues/account.ts

@@ -466,10 +466,14 @@ class AccountJazzApi<A extends Account> extends CoValueJazzApi<A> {
         | undefined;
       if (!refId) {
         const descriptor = this.schema[key];
+        const newOwnerStrategy = descriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = descriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           descriptor,
           value,
           accountOrGroupToGroup(this.account),
+          newOwnerStrategy,
+          onCreate,
         );
         refId = coValue.$jazz.id as CoID<RawCoMap>;
       }

package/src/tools/coValues/coFeed.ts

@@ -32,8 +32,6 @@ import {
   SubscribeRestArgs,
   TypeSym,
   BranchDefinition,
-} from "../internal.js";
-import {
   Account,
   CoValueBase,
   CoValueJazzApi,
@@ -379,10 +377,15 @@ export class CoFeedJazzApi<F extends CoFeed> extends CoValueJazzApi<F> {
     } else if (isRefEncoded(itemDescriptor)) {
       let refId = (item as unknown as CoValue).$jazz?.id;
       if (!refId) {
+        const newOwnerStrategy =
+          itemDescriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = itemDescriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           item,
           this.owner,
+          newOwnerStrategy,
+          onCreate,
         );
         refId = coValue.$jazz.id;
       }
@@ -720,6 +723,7 @@ export class FileStream extends CoValueBase implements CoValue {
    *
    * @param options - Configuration options for the new FileStream
    * @param options.owner - The Account or Group that will own this FileStream and control access rights
+   * @param schemaConfiguration - Internal schema configuration
    *
    * @example
    * ```typescript
@@ -743,7 +747,8 @@ export class FileStream extends CoValueBase implements CoValue {
     this: CoValueClass<S>,
     options?: { owner?: Account | Group } | Account | Group,
   ) {
-    return new this(parseCoValueCreateOptions(options));
+    const { owner } = parseCoValueCreateOptions(options);
+    return new this({ owner });
   }
 
   getMetadata(): BinaryStreamInfo | undefined {