jazz-tools 0.18.27 → 0.18.28

package/dist/tools/tests/coList.unique.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coList.unique.test.d.ts.map

package/dist/tools/tests/coList.unique.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coList.unique.test.d.ts","sourceRoot":"","sources":["../../../src/tools/tests/coList.unique.test.ts"],"names":[],"mappings":""}

package/dist/tools/tests/coMap.unique.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coMap.unique.test.d.ts.map

package/dist/tools/tests/coMap.unique.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coMap.unique.test.d.ts","sourceRoot":"","sources":["../../../src/tools/tests/coMap.unique.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -187,7 +187,7 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.18.27",
+  "version": "0.18.28",
   "dependencies": {
     "@manuscripts/prosemirror-recreate-steps": "^0.1.4",
     "@scure/base": "1.2.1",
@@ -204,9 +204,9 @@
     "prosemirror-transform": "^1.9.0",
     "use-sync-external-store": "^1.5.0",
     "zod": "4.1.11",
-    "cojson": "0.18.27",
-    "cojson-storage-indexeddb": "0.18.27",
-    "cojson-transport-ws": "0.18.27"
+    "cojson": "0.18.28",
+    "cojson-storage-indexeddb": "0.18.28",
+    "cojson-transport-ws": "0.18.28"
   },
   "devDependencies": {
     "@scure/bip39": "^1.3.0",

package/src/react-core/hooks.ts

@@ -792,6 +792,14 @@ export function useAccountWithSelector<
   );
 }
 
+/**
+ * Returns a function for logging out of the current account.
+ */
+export function useLogOut(): () => void {
+  const contextManager = useJazzContextManager();
+  return contextManager.logOut;
+}
+
 export function experimental_useInboxSender<
   I extends CoValue,
   O extends CoValue | undefined,

package/src/react-core/tests/useAccount.test.ts

@@ -64,7 +64,67 @@ describe("useAccount", () => {
     expect(result.current?.me?.root?.value).toBe("123");
   });
 
-  it("should be in sync with useIsAuthenticated when logOut is called", async () => {
+  it("should be in sync with useIsAuthenticated when logOut (from useAccount.logOut) is called", async () => {
+    const account = await createJazzTestAccount({});
+
+    const accounts: string[] = [];
+    const updates: { isAuthenticated: boolean; accountIndex: number }[] = [];
+
+    const { result } = renderHook(
+      () => {
+        const isAuthenticated = useIsAuthenticated();
+        const account = useAccount();
+
+        if (account.me) {
+          if (!accounts.includes(account.me.$jazz.id)) {
+            accounts.push(account.me.$jazz.id);
+          }
+
+          updates.push({
+            isAuthenticated,
+            accountIndex: accounts.indexOf(account.me.$jazz.id),
+          });
+        }
+
+        return { isAuthenticated, account };
+      },
+      {
+        account,
+        isAuthenticated: true,
+      },
+    );
+
+    expect(result.current?.isAuthenticated).toBe(true);
+    expect(result.current?.account?.me).toBeDefined();
+
+    const id = result.current?.account?.me?.$jazz.id;
+
+    await act(async () => {
+      await result.current?.account?.logOut();
+    });
+
+    expect(result.current?.isAuthenticated).toBe(false);
+    expect(result.current?.account?.me?.$jazz.id).not.toBe(id);
+
+    expect(updates).toMatchInlineSnapshot(`
+      [
+        {
+          "accountIndex": 0,
+          "isAuthenticated": true,
+        },
+        {
+          "accountIndex": 0,
+          "isAuthenticated": false,
+        },
+        {
+          "accountIndex": 1,
+          "isAuthenticated": false,
+        },
+      ]
+    `);
+  });
+
+  it("should be in sync with useIsAuthenticated when logOut (from useLogOut) is called", async () => {
     const account = await createJazzTestAccount({});
 
     const accounts: string[] = [];

package/src/react-core/tests/usePassPhraseAuth.test.ts

@@ -4,7 +4,7 @@ import { mnemonicToEntropy } from "@scure/bip39";
 import { AuthSecretStorage, KvStoreContext } from "jazz-tools";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { usePassphraseAuth } from "../auth/PassphraseAuth";
-import { useAccount } from "../hooks";
+import { useAccount, useLogOut } from "../hooks";
 import {
   createJazzTestAccount,
   createJazzTestGuest,
@@ -107,7 +107,7 @@ describe("usePassphraseAuth", () => {
     expect(await result.current.signUp()).toBe(passphrase);
   });
 
-  it("should be able to logout after sign up", async () => {
+  it("should be able to logout after sign up using useAccount.logOut", async () => {
     const account = await createJazzTestAccount({});
 
     const accounts: string[] = [];
@@ -177,4 +177,76 @@ describe("usePassphraseAuth", () => {
       ]
     `);
   });
+
+  it("should be able to logout after sign up using useLogout", async () => {
+    const account = await createJazzTestAccount({});
+
+    const accounts: string[] = [];
+    const updates: { state: string; accountIndex: number }[] = [];
+
+    const { result } = renderHook(
+      () => {
+        const passphraseAuth = usePassphraseAuth({ wordlist: testWordlist });
+        const account = useAccount();
+        const logOut = useLogOut();
+
+        if (account.me) {
+          if (!accounts.includes(account.me.$jazz.id)) {
+            accounts.push(account.me.$jazz.id);
+          }
+
+          updates.push({
+            state: passphraseAuth.state,
+            accountIndex: accounts.indexOf(account.me.$jazz.id),
+          });
+        }
+
+        return { passphraseAuth, account, logOut };
+      },
+      {
+        account,
+        isAuthenticated: false,
+      },
+    );
+
+    expect(result.current?.passphraseAuth.state).toBe("anonymous");
+    expect(result.current?.account?.me).toBeDefined();
+
+    const id = result.current?.account?.me?.$jazz.id;
+
+    await act(async () => {
+      await result.current?.passphraseAuth.signUp();
+    });
+
+    expect(result.current?.passphraseAuth.state).toBe("signedIn");
+    expect(result.current?.account?.me?.$jazz.id).toBe(id);
+
+    await act(async () => {
+      await result.current?.logOut();
+    });
+
+    expect(result.current?.passphraseAuth.state).toBe("anonymous");
+    expect(result.current?.account?.me?.$jazz.id).not.toBe(id);
+
+    expect(updates).toMatchInlineSnapshot(`
+      [
+        {
+          "accountIndex": 0,
+          "state": "anonymous",
+        },
+        {
+          "accountIndex": 0,
+          "state": "signedIn",
+        },
+        {
+          "accountIndex": 0,
+          "state": "anonymous",
+        },
+        {
+          "accountIndex": 1,
+          "state": "anonymous",
+        },
+      ]
+    `);
+  });
 });

package/src/tools/coValues/coList.ts

@@ -21,6 +21,8 @@ import {
   SubscribeRestArgs,
   TypeSym,
   BranchDefinition,
+  getIdFromHeader,
+  unstable_loadUnique,
 } from "../internal.js";
 import {
   AnonymousJazzAgent,
@@ -320,19 +322,17 @@ export class CoList<out Item = any>
     ownerID: ID<Account> | ID<Group>,
     as?: Account | Group | AnonymousJazzAgent,
   ) {
-    return CoList._findUnique(unique, ownerID, as);
+    const header = CoList._getUniqueHeader(unique, ownerID);
+
+    return getIdFromHeader(header, as);
   }
 
   /** @internal */
-  static _findUnique<L extends CoList>(
-    this: CoValueClass<L>,
+  static _getUniqueHeader(
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
-    as?: Account | Group | AnonymousJazzAgent,
   ) {
-    as ||= activeAccountContext.get();
-
-    const header = {
+    return {
       type: "colist" as const,
       ruleset: {
         type: "ownedByGroup" as const,
@@ -341,9 +341,6 @@ export class CoList<out Item = any>
       meta: null,
       uniqueness: unique,
     };
-    const crypto =
-      as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
-    return cojsonInternals.idforHeader(header, crypto) as ID<L>;
   }
 
   /**
@@ -378,29 +375,24 @@ export class CoList<out Item = any>
       resolve?: RefsToResolveStrict<L, R>;
     },
   ): Promise<Resolved<L, R> | null> {
-    const listId = CoList._findUnique(
+    const header = CoList._getUniqueHeader(
       options.unique,
       options.owner.$jazz.id,
-      options.owner.$jazz.loadedAs,
     );
-    let list: Resolved<L, R> | null = await loadCoValueWithoutMe(this, listId, {
-      ...options,
-      loadAs: options.owner.$jazz.loadedAs,
-      skipRetry: true,
-    });
-    if (!list) {
-      list = (this as any).create(options.value, {
-        owner: options.owner,
-        unique: options.unique,
-      }) as Resolved<L, R>;
-    } else {
-      (list as L).$jazz.applyDiff(options.value);
-    }
 
-    return await loadCoValueWithoutMe(this, listId, {
-      ...options,
-      loadAs: options.owner.$jazz.loadedAs,
-      skipRetry: true,
+    return unstable_loadUnique(this, {
+      header,
+      owner: options.owner,
+      resolve: options.resolve,
+      onCreateWhenMissing: () => {
+        (this as any).create(options.value, {
+          owner: options.owner,
+          unique: options.unique,
+        });
+      },
+      onUpdateWhenFound(value) {
+        value.$jazz.applyDiff(options.value);
+      },
     });
   }
 
@@ -411,7 +403,10 @@ export class CoList<out Item = any>
    * @param options Additional options for loading the CoList.
    * @returns The loaded CoList, or null if unavailable.
    */
-  static loadUnique<L extends CoList, const R extends RefsToResolve<L> = true>(
+  static async loadUnique<
+    L extends CoList,
+    const R extends RefsToResolve<L> = true,
+  >(
     this: CoValueClass<L>,
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
@@ -420,11 +415,19 @@ export class CoList<out Item = any>
       loadAs?: Account | AnonymousJazzAgent;
     },
   ): Promise<Resolved<L, R> | null> {
-    return loadCoValueWithoutMe(
-      this,
-      CoList._findUnique(unique, ownerID, options?.loadAs),
-      { ...options, skipRetry: true },
-    );
+    const header = CoList._getUniqueHeader(unique, ownerID);
+
+    const owner = await Group.load(ownerID, {
+      loadAs: options?.loadAs,
+    });
+
+    if (!owner) return owner;
+
+    return unstable_loadUnique(this, {
+      header,
+      owner,
+      resolve: options?.resolve,
+    });
   }
 
   // Override mutation methods defined on Array, as CoLists aren't meant to be mutated directly

package/src/tools/coValues/coMap.ts

@@ -28,6 +28,8 @@ import {
   SubscribeRestArgs,
   TypeSym,
   BranchDefinition,
+  getIdFromHeader,
+  unstable_loadUnique,
 } from "../internal.js";
 import {
   Account,
@@ -434,19 +436,17 @@ export class CoMap extends CoValueBase implements CoValue {
     ownerID: ID<Account> | ID<Group>,
     as?: Account | Group | AnonymousJazzAgent,
   ) {
-    return CoMap._findUnique(unique, ownerID, as);
+    const header = CoMap._getUniqueHeader(unique, ownerID);
+
+    return getIdFromHeader(header, as);
   }
 
   /** @internal */
-  static _findUnique<M extends CoMap>(
-    this: CoValueClass<M>,
+  static _getUniqueHeader(
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
-    as?: Account | Group | AnonymousJazzAgent,
   ) {
-    as ||= activeAccountContext.get();
-
-    const header = {
+    return {
       type: "comap" as const,
       ruleset: {
         type: "ownedByGroup" as const,
@@ -455,9 +455,6 @@ export class CoMap extends CoValueBase implements CoValue {
       meta: null,
       uniqueness: unique,
     };
-    const crypto =
-      as[TypeSym] === "Anonymous" ? as.node.crypto : as.$jazz.localNode.crypto;
-    return cojsonInternals.idforHeader(header, crypto) as ID<M>;
   }
 
   /**
@@ -497,32 +494,24 @@ export class CoMap extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<M, R>;
     },
   ): Promise<Resolved<M, R> | null> {
-    const mapId = CoMap._findUnique(
+    const header = CoMap._getUniqueHeader(
       options.unique,
       options.owner.$jazz.id,
-      options.owner.$jazz.loadedAs,
     );
-    let map: Resolved<M, R> | null = await loadCoValueWithoutMe(this, mapId, {
-      ...options,
-      loadAs: options.owner.$jazz.loadedAs,
-      skipRetry: true,
-    });
-    if (!map) {
-      const instance = new this();
-      map = CoMap._createCoMap(instance, options.value, {
-        owner: options.owner,
-        unique: options.unique,
-      }) as Resolved<M, R>;
-    } else {
-      (map as M).$jazz.applyDiff(
-        options.value as unknown as Partial<CoMapInit<M>>,
-      );
-    }
 
-    return await loadCoValueWithoutMe(this, mapId, {
-      ...options,
-      loadAs: options.owner.$jazz.loadedAs,
-      skipRetry: true,
+    return unstable_loadUnique(this, {
+      header,
+      owner: options.owner,
+      resolve: options.resolve,
+      onCreateWhenMissing: () => {
+        (this as any).create(options.value, {
+          owner: options.owner,
+          unique: options.unique,
+        });
+      },
+      onUpdateWhenFound(value) {
+        value.$jazz.applyDiff(options.value);
+      },
     });
   }
 
@@ -535,7 +524,10 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @deprecated Use `co.map(...).loadUnique` instead.
    */
-  static loadUnique<M extends CoMap, const R extends RefsToResolve<M> = true>(
+  static async loadUnique<
+    M extends CoMap,
+    const R extends RefsToResolve<M> = true,
+  >(
     this: CoValueClass<M>,
     unique: CoValueUniqueness["uniqueness"],
     ownerID: ID<Account> | ID<Group>,
@@ -544,11 +536,19 @@ export class CoMap extends CoValueBase implements CoValue {
       loadAs?: Account | AnonymousJazzAgent;
     },
   ): Promise<Resolved<M, R> | null> {
-    return loadCoValueWithoutMe(
-      this,
-      CoMap._findUnique(unique, ownerID, options?.loadAs),
-      { ...options, skipRetry: true },
-    );
+    const header = CoMap._getUniqueHeader(unique, ownerID);
+
+    const owner = await Group.load(ownerID, {
+      loadAs: options?.loadAs,
+    });
+
+    if (!owner) return owner;
+
+    return unstable_loadUnique(this, {
+      header,
+      owner,
+      resolve: options?.resolve,
+    });
   }
 }
 

package/src/tools/coValues/group.ts

@@ -9,6 +9,7 @@ import {
   type Role,
 } from "cojson";
 import {
+  AnonymousJazzAgent,
   BranchDefinition,
   CoValue,
   CoValueClass,
@@ -272,7 +273,10 @@ export class Group extends CoValueBase implements CoValue {
   static load<G extends Group, const R extends RefsToResolve<G>>(
     this: CoValueClass<G>,
     id: ID<G>,
-    options?: { resolve?: RefsToResolveStrict<G, R>; loadAs?: Account },
+    options?: {
+      resolve?: RefsToResolveStrict<G, R>;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
   ): Promise<Resolved<G, R> | null> {
     return loadCoValueWithoutMe(this, id, options);
   }

package/src/tools/coValues/inbox.ts

@@ -293,12 +293,12 @@ export class Inbox {
 
     const handleNewMessages = () => {
       for (const tx of messagesFeed.getNewItems()) {
-        const accountID = getAccountIDfromSessionID(tx.txID.sessionID);
+        const accountID = getAccountIDfromSessionID(tx.currentTxID.sessionID);
 
         if (!accountID) {
           console.warn(
             "Received message from unknown account",
-            tx.txID.sessionID,
+            tx.currentTxID.sessionID,
           );
           continue;
         }
@@ -309,7 +309,8 @@ export class Inbox {
           continue;
         }
 
-        const txKey = `${tx.txID.sessionID}/${tx.txID.txIndex}` as const;
+        const txKey =
+          `${tx.currentTxID.sessionID}/${tx.currentTxID.txIndex}` as const;
 
         if (processed.has(txKey)) {
           continue;

package/src/tools/coValues/interfaces.ts

@@ -1,4 +1,5 @@
 import {
+  cojsonInternals,
   type CoValueUniqueness,
   type CojsonInternalTypes,
   type RawCoValue,
@@ -25,6 +26,7 @@ import {
   inspect,
 } from "../internal.js";
 import type { BranchDefinition } from "../subscribe/types.js";
+import { CoValueHeader } from "cojson/dist/coValueCore/verifiedState.js";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -446,6 +448,92 @@ export function parseGroupCreateOptions(
     : { owner: options.owner ?? activeAccountContext.get() };
 }
 
+export function getIdFromHeader(
+  header: CoValueHeader,
+  loadAs?: Account | AnonymousJazzAgent | Group,
+) {
+  loadAs ||= activeAccountContext.get();
+
+  const node =
+    loadAs[TypeSym] === "Anonymous" ? loadAs.node : loadAs.$jazz.localNode;
+
+  return cojsonInternals.idforHeader(header, node.crypto);
+}
+
+export async function unstable_loadUnique<
+  V extends CoValue,
+  R extends RefsToResolve<V>,
+>(
+  cls: CoValueClass<V>,
+  options: {
+    header: CoValueHeader;
+    onCreateWhenMissing?: () => void;
+    onUpdateWhenFound?: (value: Resolved<V, R>) => void;
+    owner: Account | Group;
+    resolve?: RefsToResolveStrict<V, R>;
+  },
+): Promise<Resolved<V, R> | null> {
+  const loadAs = options.owner.$jazz.loadedAs;
+
+  const node =
+    loadAs[TypeSym] === "Anonymous" ? loadAs.node : loadAs.$jazz.localNode;
+
+  const id = cojsonInternals.idforHeader(options.header, node.crypto);
+
+  // We first try to load the unique value without using resolve and without
+  // retrying failures
+  // This way when we want to upsert we are sure that, if the load failed
+  // it failed because the unique value was missing
+  let result = await loadCoValueWithoutMe(cls, id, {
+    skipRetry: true,
+    loadAs,
+  });
+
+  if (options.onCreateWhenMissing) {
+    // if load returns unavailable, we check the state in localNode
+    // to ward against race conditions that would happen when
+    // running the same upsert unique concurrently
+    if (!result && node.getCoValue(id).hasVerifiedContent()) {
+      result = await loadCoValueWithoutMe(cls, id, {
+        loadAs,
+      });
+    }
+
+    if (!result) {
+      options.onCreateWhenMissing();
+
+      return loadCoValueWithoutMe(cls, id, {
+        loadAs,
+        resolve: options.resolve,
+      });
+    }
+  }
+
+  if (!result) return result;
+
+  if (options.onUpdateWhenFound) {
+    // we deeply load the value, retrying any failures
+    const loaded = await loadCoValueWithoutMe(cls, id, {
+      loadAs,
+      resolve: options.resolve,
+    });
+
+    if (loaded) {
+      // we don't return the update result because
+      // we want to run another load to backfill any possible partially loaded
+      // values that have been set in the update
+      options.onUpdateWhenFound(loaded);
+    } else {
+      return loaded;
+    }
+  }
+
+  return loadCoValueWithoutMe(cls, id, {
+    loadAs,
+    resolve: options.resolve,
+  });
+}
+
 /**
  * Deeply export a CoValue to a content piece.
  *

package/src/tools/exports.ts

@@ -36,6 +36,7 @@ export type {
   AccountClass,
   AccountCreationProps,
   BaseProfileShape,
+  unstable_loadUnique,
 } from "./internal.js";
 
 export {