jazz-tools 0.19.12 → 0.19.13

package/src/browser/provideBrowserLockSession/BrowserSessionProvider.ts

@@ -0,0 +1,132 @@
+import { AgentID, CryptoProvider, RawAccountID, SessionID } from "cojson";
+import { ID, Account, SessionProvider } from "jazz-tools";
+import { SessionIDStorage } from "./SessionIDStorage";
+
+export class BrowserSessionProvider implements SessionProvider {
+  async acquireSession(
+    accountID: ID<Account> | AgentID,
+    crypto: CryptoProvider,
+  ): Promise<{ sessionID: SessionID; sessionDone: () => void }> {
+    const { sessionPromise, resolveSession } = createSessionLockPromise();
+
+    // Get the list of sessions for the account, to try to acquire an existing session
+    const sessionsList = SessionIDStorage.getSessionsList(accountID);
+
+    for (const [index, sessionID] of sessionsList.entries()) {
+      const sessionAcquired = await tryToAcquireSession(
+        sessionID,
+        sessionPromise,
+      );
+
+      if (sessionAcquired) {
+        console.log("Using existing session", sessionID, "at index", index); // This log is used in the e2e tests to verify the correctness of the feature
+        return {
+          sessionID,
+          sessionDone: resolveSession,
+        };
+      }
+    }
+
+    const newSessionID = crypto.newRandomSessionID(
+      accountID as RawAccountID | AgentID,
+    );
+
+    // Acquire exclusively the session to store the new session ID for reuse in future sessions
+    await lockAndStoreSession(accountID, newSessionID, sessionPromise);
+
+    console.log("Created new session", newSessionID); // This log is used in the e2e tests to verify the correctness of the feature
+
+    return {
+      sessionID: newSessionID,
+      sessionDone: resolveSession,
+    };
+  }
+
+  async persistSession(
+    accountID: ID<Account> | AgentID,
+    sessionID: SessionID,
+  ): Promise<{ sessionDone: () => void }> {
+    const { sessionPromise, resolveSession } = createSessionLockPromise();
+
+    // Store the session id for future use and lock it until the session is done
+    await lockAndStoreSession(accountID, sessionID, sessionPromise);
+
+    console.log("Stored new session", sessionID);
+
+    return { sessionDone: resolveSession };
+  }
+}
+
+async function lockAndStoreSession(
+  accountID: ID<Account> | AgentID,
+  sessionID: SessionID,
+  sessionPromise: Promise<void>,
+) {
+  const sessionAcquired = await tryToAcquireSession(sessionID, sessionPromise);
+
+  if (!sessionAcquired) {
+    // This should never happen because the session has been randomly generated
+    throw new Error("Couldn't get lock on new session");
+  }
+
+  // We don't need to wait for this to finish, we only need to acquire the lock on the new session
+  storeSessionID(accountID, sessionID);
+}
+
+function tryToAcquireSession(
+  sessionID: SessionID,
+  sessionDonePromise: Promise<void>,
+) {
+  return new Promise<boolean>((resolve) => {
+    // Acquire exclusively the session if available
+    navigator.locks.request(
+      `load_session_${sessionID}`,
+      { mode: "exclusive", ifAvailable: true },
+      async (lock) => {
+        if (!lock) {
+          resolve(false); // Session already in use
+          return;
+        }
+
+        resolve(true); // Session is available
+
+        // Return the promise to lock the session until sessionDone is called
+        return sessionDonePromise;
+      },
+    );
+  });
+}
+
+function storeSessionID(
+  accountID: ID<Account> | AgentID,
+  sessionID: SessionID,
+) {
+  return navigator.locks.request(
+    `store_session_${accountID}`,
+    { mode: "exclusive" },
+    async (lock) => {
+      if (!lock) {
+        console.error("Couldn't get lock to store session ID", accountID);
+      }
+
+      const sessionsList = SessionIDStorage.getSessionsList(accountID);
+      SessionIDStorage.storeSessionID(
+        accountID,
+        sessionID,
+        sessionsList.length,
+      );
+    },
+  );
+}
+
+function createSessionLockPromise() {
+  let resolveSession: () => void;
+  const sessionPromise = new Promise<void>((resolve) => {
+    resolveSession = resolve;
+  });
+
+  return {
+    sessionPromise,
+    resolveSession: resolveSession!,
+  };
+}

package/src/browser/provideBrowserLockSession/SessionIDStorage.ts

@@ -0,0 +1,33 @@
+import { SessionID } from "cojson";
+
+function getSessionKey(accountID: string, index: number) {
+  return accountID + "_" + index;
+}
+
+export class SessionIDStorage {
+  static getSessionsList(accountID: string) {
+    let sessionsList: SessionID[] = [];
+    let i = 0;
+    let lastSessionID: SessionID | null;
+
+    do {
+      lastSessionID = localStorage.getItem(
+        getSessionKey(accountID, i),
+      ) as SessionID | null;
+      if (lastSessionID) {
+        sessionsList.push(lastSessionID);
+      }
+      i++;
+    } while (lastSessionID);
+
+    return sessionsList;
+  }
+
+  static storeSessionID(
+    accountID: string,
+    sessionID: SessionID,
+    index: number,
+  ) {
+    localStorage.setItem(getSessionKey(accountID, index), sessionID);
+  }
+}

package/src/browser/provideBrowserLockSession/index.ts

@@ -0,0 +1,11 @@
+import { MockSessionProvider } from "jazz-tools";
+import { BrowserSessionProvider } from "./BrowserSessionProvider";
+
+export function getBrowserLockSessionProvider() {
+  if (typeof navigator === "undefined" || !navigator.locks?.request) {
+    // Fallback to random session ID for each tab session
+    return new MockSessionProvider();
+  }
+
+  return new BrowserSessionProvider();
+}

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/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 {

package/src/tools/coValues/coList.ts

@@ -26,8 +26,6 @@ import {
   getIdFromHeader,
   internalLoadUnique,
   CoValueLoadingState,
-} from "../internal.js";
-import {
   AnonymousJazzAgent,
   ItemsSym,
   Ref,
@@ -172,8 +170,8 @@ export class CoList<out Item = any>
       | Account
       | Group,
   ) {
-    const { owner, uniqueness } = parseCoValueCreateOptions(options);
     const instance = new this();
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
 
     Object.defineProperties(instance, {
       $jazz: {
@@ -918,10 +916,15 @@ function toRawItems<Item>(
       }
       let refId = (value as unknown as CoValue).$jazz?.id;
       if (!refId) {
+        const newOwnerStrategy =
+          itemDescriptor.permissions?.newInlineOwnerStrategy;
+        const onCreate = itemDescriptor.permissions?.onCreate;
         const coValue = instantiateRefEncodedWithInit(
           itemDescriptor,
           value,
           owner,
+          newOwnerStrategy,
+          onCreate,
         );
         refId = coValue.$jazz.id;
       }

package/src/tools/coValues/coMap.ts

@@ -298,10 +298,15 @@ export class CoMap extends CoValueBase implements CoValue {
           if (initValue != null) {
             let refId = (initValue as unknown as CoValue).$jazz?.id;
             if (!refId) {
+              const newOwnerStrategy =
+                descriptor.permissions?.newInlineOwnerStrategy;
+              const onCreate = descriptor.permissions?.onCreate;
               const coValue = instantiateRefEncodedWithInit(
                 descriptor,
                 initValue,
                 owner,
+                newOwnerStrategy,
+                onCreate,
               );
               refId = coValue.$jazz.id;
             }
@@ -610,10 +615,15 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
         this.raw.set(key, null);
       } else {
         if (!refId) {
+          const newOwnerStrategy =
+            descriptor.permissions?.newInlineOwnerStrategy;
+          const onCreate = descriptor.permissions?.onCreate;
           const coValue = instantiateRefEncodedWithInit(
             descriptor,
             value,
             this.owner,
+            newOwnerStrategy,
+            onCreate,
           );
           refId = coValue.$jazz.id;
         }

package/src/tools/coValues/coVector.ts

@@ -129,7 +129,8 @@ export class CoVector
       );
     }
 
-    const coVector = new this(parseCoValueCreateOptions(options));
+    const { owner } = parseCoValueCreateOptions(options);
+    const coVector = new this({ owner });
     coVector.setVectorData(vectorAsFloat32Array);
 
     const byteArray = CoVector.toByteArray(vectorAsFloat32Array);

package/src/tools/coValues/group.ts

@@ -48,6 +48,11 @@ type GroupMember = {
   account: Account;
 };
 
+/**
+ * Roles that can be granted to a group member.
+ */
+export type GroupRole = "reader" | "writer" | "admin" | "manager";
+
 /** @category Identity & Permissions */
 export class Group extends CoValueBase implements CoValue {
   declare [TypeSym]: "Group";
@@ -107,10 +112,7 @@ export class Group extends CoValueBase implements CoValue {
    * @param member The group that will gain access to this group.
    * @param role The role all members of the parent group should have in this group.
    */
-  addMember(
-    member: Group,
-    role?: "reader" | "writer" | "admin" | "manager" | "inherit",
-  ): void;
+  addMember(member: Group, role?: GroupRole | "inherit"): void;
   addMember(
     member: Group | Account,
     role: "reader" | "writer" | "admin" | "manager",

package/src/tools/coValues/interfaces.ts

@@ -11,10 +11,11 @@ import {
   CoValueClassOrSchema,
   CoValueLoadingState,
   NotLoadedCoValueState,
-  type Group,
+  Group,
   Loaded,
   Inaccessible,
   MaybeLoaded,
+  OnCreateCallback,
   Settled,
   RefsToResolve,
   RefsToResolveStrict,
@@ -424,6 +425,7 @@ export function parseCoValueCreateOptions(
     | {
         owner?: Account | Group;
         unique?: CoValueUniqueness["uniqueness"];
+        onCreate?: OnCreateCallback;
       }
     | Account
     | Group
@@ -432,16 +434,22 @@ export function parseCoValueCreateOptions(
   owner: Group;
   uniqueness?: CoValueUniqueness;
 } {
+  const onCreate =
+    options && "onCreate" in options ? options.onCreate : undefined;
   const Group = RegisteredSchemas["Group"];
-
   if (!options) {
-    return { owner: Group.create(), uniqueness: undefined };
+    const owner = Group.create();
+    onCreate?.(owner);
+    return { owner, uniqueness: undefined };
   }
 
   if (TypeSym in options) {
     if (options[TypeSym] === "Account") {
-      return { owner: accountOrGroupToGroup(options), uniqueness: undefined };
+      const owner = accountOrGroupToGroup(options);
+      onCreate?.(owner);
+      return { owner, uniqueness: undefined };
     } else if (options[TypeSym] === "Group") {
+      onCreate?.(options);
       return { owner: options, uniqueness: undefined };
     }
   }
@@ -450,10 +458,14 @@ export function parseCoValueCreateOptions(
     ? { uniqueness: options.unique }
     : undefined;
 
+  const owner = options.owner
+    ? accountOrGroupToGroup(options.owner)
+    : Group.create();
+
+  onCreate?.(owner);
+
   const opts = {
-    owner: options.owner
-      ? accountOrGroupToGroup(options.owner)
-      : Group.create(),
+    owner,
     uniqueness,
   };
   return opts;

package/src/tools/exports.ts

@@ -66,6 +66,7 @@ export {
   createUnloadedCoValue,
   unstable_loadUnique,
   getUnloadedCoValueWithoutId,
+  setDefaultSchemaPermissions,
 } from "./internal.js";
 
 export {
@@ -100,7 +101,8 @@ export {
   createJazzContextFromExistingCredentials,
   createJazzContextForNewAccount,
   createJazzContext,
-  randomSessionProvider,
+  SessionProvider,
+  MockSessionProvider,
   type AuthResult,
   type Credentials,
   type JazzContextWithAccount,