jazz-tools 0.19.10 → 0.19.12

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/coValues/account.ts

@@ -273,7 +273,13 @@ export class Account extends CoValueBase implements CoValue {
       creationProps: { name: string };
       onCreate?: (account: A, worker: Account) => Promise<void>;
     },
-  ) {
+  ): Promise<{
+    credentials: {
+      accountID: string;
+      accountSecret: AgentSecret;
+    };
+    account: A;
+  }> {
     const crypto = worker.$jazz.localNode.crypto;
 
     const connectedPeers = cojsonInternals.connectedPeers(
@@ -290,6 +296,11 @@ export class Account extends CoValueBase implements CoValue {
       peers: [connectedPeers[0]],
     });
 
+    const credentials = {
+      accountID: account.$jazz.id,
+      accountSecret: account.$jazz.localNode.getCurrentAgent().agentSecret,
+    };
+
     // Load the worker inside the account node
     const loadedWorker = await Account.load(worker.$jazz.id, {
       loadAs: account,
@@ -314,7 +325,7 @@ export class Account extends CoValueBase implements CoValue {
     // Close the account node, to avoid leaking memory
     account.$jazz.localNode.gracefulShutdown();
 
-    return createdAccount;
+    return { credentials, account: createdAccount };
   }
 
   static fromNode<A extends Account>(

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/implementation/zodSchema/schemaTypes/AccountSchema.ts

@@ -26,6 +26,7 @@ import {
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
 import { CoreResolveQuery } from "./CoValueSchema.js";
 import { withSchemaResolveQuery } from "../../schemaUtils.js";
+import { AgentSecret } from "cojson";
 
 export type BaseProfileShape = {
   name: z.core.$ZodString<string>;
@@ -103,8 +104,14 @@ export class AccountSchema<
         worker: Account,
       ) => Promise<void>;
     },
+  ): Promise<{
+    credentials: {
+      accountID: string;
+      accountSecret: AgentSecret;
+    };
     // @ts-expect-error we can't statically enforce the schema's resolve query is a valid resolve query, but in practice it is
-  ): Promise<Loaded<AccountSchema<Shape>, DefaultResolveQuery>> {
+    account: Loaded<AccountSchema<Shape>, DefaultResolveQuery>;
+  }> {
     // @ts-expect-error
     return this.coValueClass.createAs(worker, options);
   }

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

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

@@ -467,7 +467,7 @@ describe("createAs", () => {
       { owner: worker },
     );
 
-    const createdAccount = await CustomAccount.createAs(worker, {
+    const created = await CustomAccount.createAs(worker, {
       creationProps: { name: "Test Account" },
       onCreate: async (account, loadedWorker) => {
         executionOrder.push("onCreate");
@@ -490,11 +490,18 @@ describe("createAs", () => {
       },
     });
 
-    assertLoaded(createdAccount);
-    assertLoaded(createdAccount.root);
+    assertLoaded(created.account);
+    assertLoaded(created.account.root);
+
+    expect(created.credentials.accountID).toBe(created.account.$jazz.id);
+    // ensure we get the created, not the creat*ing* account credentials
+    expect(created.credentials.accountID).not.toBe(worker.$jazz.id);
+    expect(created.credentials.accountSecret).not.toBe(
+      worker.$jazz.localNode.getCurrentAgent().agentSecret,
+    );
 
     // Verify onCreate was called and root was set from worker
-    expect(createdAccount.root.value).toBe("worker-root");
+    expect(created.account.root.value).toBe("worker-root");
 
     // Verify execution order
     expect(executionOrder).toEqual(["migration", "onCreate"]);

package/src/tools/tests/schema.resolved.test.ts

@@ -246,7 +246,7 @@ describe("Schema.resolved()", () => {
           profile: true,
         });
 
-        const account = await AccountWithProfile.createAs(serverAccount, {
+        const { account } = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(
@@ -405,7 +405,7 @@ describe("Schema.resolved()", () => {
       test("for Account", async () => {
         const AccountWithProfile = co.account().resolved({ profile: true });
 
-        const account = await AccountWithProfile.createAs(serverAccount, {
+        const { account } = await AccountWithProfile.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(
@@ -561,7 +561,7 @@ describe("Schema.resolved()", () => {
           .list(TestAccount)
           .resolved({ $each: TestAccount.resolveQuery });
 
-        const account = await TestAccount.createAs(serverAccount, {
+        const { account } = await TestAccount.createAs(serverAccount, {
           creationProps: { name: "Hermes Puggington" },
           onCreate: async (account) => {
             account.$jazz.set(

package/tsup.config.ts

@@ -58,6 +58,7 @@ export default defineConfig([
     ...cfg,
     entry: {
       index: "src/inspector/index.tsx",
+      standalone: "src/inspector/standalone.tsx",
     },
     outDir: "dist/inspector",
     esbuildOptions: (options) => {