jazz-tools 0.18.23 → 0.18.25

package/src/svelte/Provider.svelte

@@ -19,10 +19,12 @@
   let props: JazzContextManagerProps<S> & {
     children?: Snippet;
     enableSSR?: boolean;
+    authSecretStorageKey?: string;
   } = $props();
 
   const contextManager = new JazzBrowserContextManager<S>({
     useAnonymousFallback: props.enableSSR,
+    authSecretStorageKey: props.authSecretStorageKey,
   });
 
   const ctx = $state<JazzContext<InstanceOfSchema<S>>>({ current: undefined });

package/src/tools/auth/AuthSecretStorage.ts

@@ -3,6 +3,7 @@ import type { Account } from "../coValues/account.js";
 import type { ID } from "../internal.js";
 import { AuthCredentials } from "../types.js";
 import KvStoreContext from "./KvStoreContext.js";
+import { z } from "zod/v4";
 
 const STORAGE_KEY = "jazz-logged-in-secret";
 
@@ -24,20 +25,26 @@ export class AuthSecretStorage {
   private listeners: Set<(isAuthenticated: boolean) => void>;
   public isAuthenticated: boolean;
 
-  constructor() {
+  constructor(private storageKey: string = STORAGE_KEY) {
+    z.string().nonempty().parse(storageKey);
+
     this.listeners = new Set();
     this.isAuthenticated = false;
   }
 
+  getStorageKey(): string {
+    return this.storageKey;
+  }
+
   async migrate() {
     const kvStore = KvStoreContext.getInstance().getStorage();
 
-    if (!(await kvStore.get(STORAGE_KEY))) {
+    if (!(await kvStore.get(this.storageKey))) {
       const demoAuthSecret = await kvStore.get("demo-auth-logged-in-secret");
       if (demoAuthSecret) {
         const parsed = JSON.parse(demoAuthSecret);
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             accountSecret: parsed.accountSecret,
@@ -51,7 +58,7 @@ export class AuthSecretStorage {
       if (clerkAuthSecret) {
         const parsed = JSON.parse(clerkAuthSecret);
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             accountSecret: parsed.secret,
@@ -62,14 +69,14 @@ export class AuthSecretStorage {
       }
     }
 
-    const value = await kvStore.get(STORAGE_KEY);
+    const value = await kvStore.get(this.storageKey);
 
     if (value) {
       const parsed = JSON.parse(value);
 
       if ("secret" in parsed) {
         await kvStore.set(
-          STORAGE_KEY,
+          this.storageKey,
           JSON.stringify({
             accountID: parsed.accountID,
             secretSeed: parsed.secretSeed,
@@ -83,7 +90,7 @@ export class AuthSecretStorage {
 
   async get(): Promise<AuthCredentials | null> {
     const kvStore = KvStoreContext.getInstance().getStorage();
-    const data = await kvStore.get(STORAGE_KEY);
+    const data = await kvStore.get(this.storageKey);
 
     if (!data) return null;
 
@@ -106,7 +113,7 @@ export class AuthSecretStorage {
   async setWithoutNotify(payload: AuthSetPayload) {
     const kvStore = KvStoreContext.getInstance().getStorage();
     await kvStore.set(
-      STORAGE_KEY,
+      this.storageKey,
       JSON.stringify({
         accountID: payload.accountID,
         secretSeed: payload.secretSeed
@@ -148,7 +155,7 @@ export class AuthSecretStorage {
 
   async clearWithoutNotify() {
     const kvStore = KvStoreContext.getInstance().getStorage();
-    await kvStore.delete(STORAGE_KEY);
+    await kvStore.delete(this.storageKey);
   }
 
   async clear() {

package/src/tools/coValues/account.ts

@@ -120,13 +120,13 @@ export class Account extends CoValueBase implements CoValue {
    *
    * @param valueID The ID of the `CoValue` or `Group` to accept the invite to.
    * @param inviteSecret The secret of the invite to accept.
-   * @param coValueClass The class of the `CoValue` or `Group` to accept the invite to.
+   * @param coValueClass [Group] The class of the `CoValue` or `Group` to accept the invite to.
    * @returns The loaded `CoValue` or `Group`.
    */
   async acceptInvite<S extends CoValueClassOrSchema>(
     valueID: string,
     inviteSecret: InviteSecret,
-    coValueClass: S,
+    coValueClass?: S,
   ): Promise<Resolved<InstanceOrPrimitiveOfSchema<S>, true> | null> {
     if (!this.$jazz.isLocalNodeOwner) {
       throw new Error("Only a controlled account can accept invites");
@@ -138,7 +138,7 @@ export class Account extends CoValueBase implements CoValue {
     );
 
     return loadCoValue(
-      coValueClassFromCoValueClassOrSchema(coValueClass),
+      coValueClassFromCoValueClassOrSchema(coValueClass ?? Group),
       valueID,
       {
         loadAs: this,
@@ -212,7 +212,7 @@ export class Account extends CoValueBase implements CoValue {
     options: {
       creationProps: { name: string };
       initialAgentSecret?: AgentSecret;
-      peersToLoadFrom?: Peer[];
+      peers?: Peer[];
       crypto: CryptoProvider;
     },
   ): Promise<A> {
@@ -256,7 +256,7 @@ export class Account extends CoValueBase implements CoValue {
     const account = await this.create<A>({
       creationProps: options.creationProps,
       crypto: as.$jazz.localNode.crypto,
-      peersToLoadFrom: [connectedPeers[0]],
+      peers: [connectedPeers[0]],
     });
 
     await account.$jazz.waitForAllCoValuesSync();

package/src/tools/coValues/group.ts

@@ -3,6 +3,7 @@ import {
   type AccountRole,
   type AgentID,
   type Everyone,
+  type InviteSecret,
   type RawAccountID,
   type RawGroup,
   type Role,
@@ -299,6 +300,29 @@ export class Group extends CoValueBase implements CoValue {
     const { options, listener } = parseSubscribeRestArgs(args);
     return subscribeToCoValueWithoutMe<G, R>(this, id, options, listener);
   }
+
+  /** @category Invites
+   * Creates a group invite
+   * @param id The ID of the group to create an invite for
+   * @param options Optional configuration
+   * @param options.role The role to grant to the accepter of the invite. Defaults to 'reader'
+   * @param options.loadAs The account to use when loading the group. Defaults to the current account
+   * @returns An invite secret, (a string starting with "inviteSecret_"). Can be
+   * accepted using `Account.acceptInvite()`
+   */
+  static async createInvite<G extends Group>(
+    this: CoValueClass<G>,
+    id: ID<G>,
+    options?: { role?: AccountRole; loadAs?: Account },
+  ): Promise<InviteSecret> {
+    const group = await loadCoValueWithoutMe(this, id, {
+      loadAs: options?.loadAs,
+    });
+    if (!group) {
+      throw new Error(`Group with id ${id} not found`);
+    }
+    return group.$jazz.createInvite(options?.role ?? "reader");
+  }
 }
 
 export class GroupJazzApi<G extends Group> extends CoValueJazzApi<G> {
@@ -350,6 +374,15 @@ export class GroupJazzApi<G extends Group> extends CoValueJazzApi<G> {
     return subscribeToExistingCoValue(this.group, options, listener);
   }
 
+  /**
+   * Create an invite to this group
+   *
+   * @category Invites
+   */
+  createInvite(role: AccountRole = "reader"): InviteSecret {
+    return this.raw.createInvite(role);
+  }
+
   /**
    * Wait for the `Group` to be uploaded to the other peers.
    *

package/src/tools/coValues/interfaces.ts

@@ -301,7 +301,10 @@ export function subscribeToCoValue<
     if (value.type === "unavailable") {
       options.onUnavailable?.();
 
-      console.error(value.toString());
+      // Don't log unavailable errors when `loadUnique` or `upsertUnique` are used
+      if (!options.skipRetry) {
+        console.error(value.toString());
+      }
     } else if (value.type === "unauthorized") {
       options.onUnauthorized?.();
 

package/src/tools/implementation/ContextManager.ts

@@ -45,7 +45,7 @@ type PlatformSpecificContext<Acc extends Account> =
 
 function getAnonymousFallback() {
   const context = createAnonymousJazzContext({
-    peersToLoadFrom: [],
+    peers: [],
     crypto: new PureJSCrypto(),
   });
 
@@ -71,13 +71,17 @@ export class JazzContextManager<
   protected value: JazzContextType<Acc> | undefined;
   protected context: PlatformSpecificContext<Acc> | undefined;
   protected props: P | undefined;
-  protected authSecretStorage = new AuthSecretStorage();
+  protected authSecretStorage;
   protected keepContextOpen = false;
   contextPromise: Promise<void> | undefined;
   protected authenticatingAccountID: string | null = null;
 
-  constructor(opts?: { useAnonymousFallback?: boolean }) {
+  constructor(opts?: {
+    useAnonymousFallback?: boolean;
+    authSecretStorageKey?: string;
+  }) {
     KvStoreContext.getInstance().initialize(this.getKvStore());
+    this.authSecretStorage = new AuthSecretStorage(opts?.authSecretStorageKey);
 
     if (opts?.useAnonymousFallback) {
       this.value = getAnonymousFallback();

package/src/tools/implementation/createContext.ts

@@ -90,7 +90,7 @@ export async function createJazzContextFromExistingCredentials<
     | CoreAccountSchema,
 >({
   credentials,
-  peersToLoadFrom,
+  peers,
   crypto,
   storage,
   AccountSchema: PropsAccountSchema,
@@ -99,7 +99,7 @@ export async function createJazzContextFromExistingCredentials<
   asActiveAccount,
 }: {
   credentials: Credentials;
-  peersToLoadFrom: Peer[];
+  peers: Peer[];
   crypto: CryptoProvider;
   AccountSchema?: S;
   sessionProvider: SessionProvider;
@@ -122,7 +122,7 @@ export async function createJazzContextFromExistingCredentials<
     accountID: credentials.accountID as unknown as CoID<RawAccount>,
     accountSecret: credentials.secret,
     sessionID: sessionID,
-    peersToLoadFrom: peersToLoadFrom,
+    peers: peers,
     crypto: crypto,
     storage,
     migration: async (rawAccount, _node, creationProps) => {
@@ -162,7 +162,7 @@ export async function createJazzContextForNewAccount<
 >({
   creationProps,
   initialAgentSecret,
-  peersToLoadFrom,
+  peers,
   crypto,
   AccountSchema: PropsAccountSchema,
   onLogOut,
@@ -170,7 +170,7 @@ export async function createJazzContextForNewAccount<
 }: {
   creationProps: { name: string };
   initialAgentSecret?: AgentSecret;
-  peersToLoadFrom: Peer[];
+  peers: Peer[];
   crypto: CryptoProvider;
   AccountSchema?: S;
   onLogOut?: () => Promise<void>;
@@ -184,7 +184,7 @@ export async function createJazzContextForNewAccount<
 
   const { node } = await LocalNode.withNewlyCreatedAccount({
     creationProps,
-    peersToLoadFrom,
+    peers,
     crypto,
     initialAgentSecret,
     storage,
@@ -219,7 +219,7 @@ export async function createJazzContext<
 >(options: {
   credentials?: AuthCredentials;
   newAccountProps?: NewAccountProps;
-  peersToLoadFrom: Peer[];
+  peers: Peer[];
   crypto: CryptoProvider;
   defaultProfileName?: string;
   AccountSchema?: S;
@@ -243,7 +243,7 @@ export async function createJazzContext<
         accountID: credentials.accountID,
         secret: credentials.accountSecret,
       },
-      peersToLoadFrom: options.peersToLoadFrom,
+      peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
       sessionProvider: options.sessionProvider,
@@ -267,7 +267,7 @@ export async function createJazzContext<
     context = await createJazzContextForNewAccount({
       creationProps,
       initialAgentSecret,
-      peersToLoadFrom: options.peersToLoadFrom,
+      peers: options.peers,
       crypto,
       AccountSchema: options.AccountSchema,
       onLogOut: async () => {
@@ -293,11 +293,11 @@ export async function createJazzContext<
 }
 
 export function createAnonymousJazzContext({
-  peersToLoadFrom,
+  peers,
   crypto,
   storage,
 }: {
-  peersToLoadFrom: Peer[];
+  peers: Peer[];
   crypto: CryptoProvider;
   storage?: StorageAPI;
 }): JazzContextWithAgent {
@@ -309,7 +309,7 @@ export function createAnonymousJazzContext({
     crypto,
   );
 
-  for (const peer of peersToLoadFrom) {
+  for (const peer of peers) {
     node.syncManager.addPeer(peer);
   }
 

package/src/tools/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -1,10 +1,10 @@
-import { CryptoProvider } from "cojson";
 import {
   Account,
   AccountCreationProps,
   BranchDefinition,
   Group,
   RefsToResolveStrict,
+  Simplify,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { InstanceOrPrimitiveOfSchema } from "../typeConverters/InstanceOrPrimitiveOfSchema.js";
@@ -48,10 +48,9 @@ export interface AccountSchema<
     > {
   builtin: "Account";
 
-  create: (options: {
-    creationProps?: { name: string };
-    crypto?: CryptoProvider;
-  }) => Promise<AccountInstance<Shape>>;
+  create: (
+    options: Simplify<Parameters<(typeof Account)["create"]>[0]>,
+  ) => Promise<AccountInstance<Shape>>;
 
   load: <R extends ResolveQuery<AccountSchema<Shape>>>(
     id: string,
@@ -61,6 +60,7 @@ export interface AccountSchema<
     },
   ) => Promise<Loaded<AccountSchema<Shape>, R> | null>;
 
+  /** @internal */
   createAs: (
     as: Account,
     options: {

package/src/tools/implementation/zodSchema/schemaTypes/GroupSchema.ts

@@ -14,6 +14,7 @@ import {
 import { CoreCoValueSchema } from "./CoValueSchema.js";
 import { coOptionalDefiner } from "../zodCo.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
+import type { AccountRole, InviteSecret } from "cojson";
 
 export interface CoreGroupSchema extends CoreCoValueSchema {
   builtin: "Group";
@@ -51,7 +52,12 @@ export class GroupSchema implements CoreGroupSchema {
   ): Promise<Group | null> {
     return Group.load(id, options);
   }
-
+  createInvite<G extends Group>(
+    id: ID<G>,
+    options?: { role?: AccountRole; loadAs?: Account },
+  ): Promise<InviteSecret> {
+    return Group.createInvite(id, options);
+  }
   subscribe<G extends Group, const R extends RefsToResolve<G>>(
     id: ID<G>,
     listener: (value: Resolved<G, R>, unsubscribe: () => void) => void,

package/src/tools/ssr/ssr.ts

@@ -5,7 +5,7 @@ import { createAnonymousJazzContext } from "jazz-tools";
 export function createSSRJazzAgent(opts: { peer: string }) {
   const ssrNode = createAnonymousJazzContext({
     crypto: new PureJSCrypto(),
-    peersToLoadFrom: [],
+    peers: [],
   });
 
   const wsPeer = new WebSocketPeerWithReconnection({

package/src/tools/testing.ts

@@ -112,7 +112,7 @@ export async function createJazzTestAccount<
     },
     initialAgentSecret: crypto.agentSecretFromSecretSeed(secretSeed),
     crypto,
-    peersToLoadFrom: peers,
+    peers: peers,
     migration: async (rawAccount, _node, creationProps) => {
       if (isMigrationActive) {
         throw new Error(
@@ -185,7 +185,7 @@ export function runWithoutActiveAccount<Result>(
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
     crypto: await PureJSCrypto.create(),
-    peersToLoadFrom: [],
+    peers: [],
   });
 
   return {
@@ -318,7 +318,7 @@ export class TestJazzContextManager<
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,
-      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      peers: [getPeerConnectedToTestSyncServer()],
       crypto: await TestJSCrypto.create(),
       sessionProvider: randomSessionProvider,
       authSecretStorage: this.getAuthSecretStorage(),

package/src/tools/tests/AuthSecretStorage.test.ts

@@ -1,6 +1,6 @@
 // @vitest-environment happy-dom
 
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { AuthSecretStorage } from "../auth/AuthSecretStorage";
 import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
 import KvStoreContext from "../auth/KvStoreContext";
@@ -428,4 +428,62 @@ describe("AuthSecretStorage", () => {
       });
     });
   });
+
+  describe("configurable secret storage key", () => {
+    const KEY = "test-auth-secret";
+    beforeEach(() => {
+      kvStore.clearAll();
+      authSecretStorage = new AuthSecretStorage(KEY);
+    });
+
+    afterAll(() => {
+      // Restore the default storage key
+      authSecretStorage = new AuthSecretStorage();
+    });
+
+    it("should throw an error if the storage key is empty", () => {
+      expect(() => new AuthSecretStorage("")).toThrow(
+        "Too small: expected string to have >=1 characters",
+      );
+    });
+
+    it("should use the configured storage key on get", async () => {
+      const credentials = {
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "anonymous",
+      };
+      await kvStore.set(KEY, JSON.stringify(credentials));
+
+      const result = await authSecretStorage.get();
+
+      expect(result).toEqual({
+        accountID: "test123",
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret: "secret123",
+        provider: "anonymous",
+      });
+    });
+
+    it("should use the configured storage key on set", async () => {
+      const payload = {
+        accountID: "test123" as ID<Account>,
+        secretSeed: new Uint8Array([1, 2, 3]),
+        accountSecret:
+          "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
+        provider: "passphrase",
+      };
+
+      await authSecretStorage.set(payload);
+
+      const stored = JSON.parse((await kvStore.get(KEY))!);
+      expect(stored).toEqual({
+        accountID: "test123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "secret123",
+        provider: "passphrase",
+      });
+    });
+  });
 });

package/src/tools/tests/ContextManager.test.ts

@@ -56,7 +56,7 @@ class TestJazzContextManager<Acc extends Account> extends JazzContextManager<
       credentials: authProps?.credentials,
       defaultProfileName: props.defaultProfileName,
       newAccountProps: authProps?.newAccountProps,
-      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
+      peers: [getPeerConnectedToTestSyncServer()],
       crypto: Crypto,
       sessionProvider: randomSessionProvider,
       authSecretStorage: this.getAuthSecretStorage(),
@@ -541,6 +541,16 @@ describe("ContextManager", () => {
     ).rejects.toThrow("Props required");
   });
 
+  describe("configurable storage key", () => {
+    test("uses the configured storage key", async () => {
+      const KEY = "test-auth-secret";
+      const manager = new TestJazzContextManager<Account>({
+        authSecretStorageKey: KEY,
+      });
+      expect(manager.getAuthSecretStorage().getStorageKey()).toBe(KEY);
+    });
+  });
+
   describe("Race condition handling", () => {
     test("prevents concurrent authentication attempts", async () => {
       const account = await createJazzTestAccount();

package/src/tools/tests/account.test.ts

@@ -409,3 +409,19 @@ describe("account.toJSON", () => {
     });
   });
 });
+
+describe("accepting invites", () => {
+  test("accepting an invite to a Group", async () => {
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+    const group = co.group().create();
+    const invite = group.$jazz.createInvite("reader");
+    const newAccount = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+    expect(group.getRoleOf(newAccount.$jazz.id)).toBeUndefined();
+    await newAccount.acceptInvite(group.$jazz.id, invite);
+    expect(group.getRoleOf(newAccount.$jazz.id)).toBe("reader");
+  });
+});

package/src/tools/tests/coPlainText.test.ts

@@ -205,7 +205,7 @@ describe("CoPlainText", () => {
             secret: me.$jazz.localNode.getCurrentAgent().agentSecret,
           },
           sessionProvider: randomSessionProvider,
-          peersToLoadFrom: [initialAsPeer],
+          peers: [initialAsPeer],
           crypto: Crypto,
           asActiveAccount: true,
         });
@@ -237,7 +237,7 @@ describe("CoPlainText", () => {
           secret: me.$jazz.localNode.getCurrentAgent().agentSecret,
         },
         sessionProvider: randomSessionProvider,
-        peersToLoadFrom: [initialAsPeer],
+        peers: [initialAsPeer],
         crypto: Crypto,
         asActiveAccount: true,
       });