jazz-tools 0.15.7 → 0.15.9

package/src/tools/implementation/createContext.ts

@@ -8,6 +8,7 @@ import {
   RawAccount,
   RawAccountID,
   SessionID,
+  StorageAPI,
 } from "cojson";
 import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { type Account, type AccountClass } from "../coValues/account.js";
@@ -93,6 +94,7 @@ export async function createJazzContextFromExistingCredentials<
   credentials,
   peersToLoadFrom,
   crypto,
+  storage,
   AccountSchema: PropsAccountSchema,
   sessionProvider,
   onLogOut,
@@ -103,6 +105,7 @@ export async function createJazzContextFromExistingCredentials<
   AccountSchema?: S;
   sessionProvider: SessionProvider;
   onLogOut?: () => void;
+  storage?: StorageAPI;
 }): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const { sessionID, sessionDone } = await sessionProvider(
     credentials.accountID,
@@ -120,6 +123,7 @@ export async function createJazzContextFromExistingCredentials<
     sessionID: sessionID,
     peersToLoadFrom: peersToLoadFrom,
     crypto: crypto,
+    storage,
     migration: async (rawAccount, _node, creationProps) => {
       const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
       activeAccountContext.set(account);
@@ -157,6 +161,7 @@ export async function createJazzContextForNewAccount<
   crypto,
   AccountSchema: PropsAccountSchema,
   onLogOut,
+  storage,
 }: {
   creationProps: { name: string };
   initialAgentSecret?: AgentSecret;
@@ -164,6 +169,7 @@ export async function createJazzContextForNewAccount<
   crypto: CryptoProvider;
   AccountSchema?: S;
   onLogOut?: () => Promise<void>;
+  storage?: StorageAPI;
 }): Promise<JazzContextWithAccount<InstanceOfSchema<S>>> {
   const CurrentAccountSchema =
     PropsAccountSchema ?? (RegisteredSchemas["Account"] as unknown as S);
@@ -175,6 +181,7 @@ export async function createJazzContextForNewAccount<
     peersToLoadFrom,
     crypto,
     initialAgentSecret,
+    storage,
     migration: async (rawAccount, _node, creationProps) => {
       const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
       activeAccountContext.set(account);
@@ -212,6 +219,7 @@ export async function createJazzContext<
   AccountSchema?: S;
   sessionProvider: SessionProvider;
   authSecretStorage: AuthSecretStorage;
+  storage?: StorageAPI;
 }) {
   const crypto = options.crypto;
 
@@ -236,6 +244,7 @@ export async function createJazzContext<
       onLogOut: () => {
         authSecretStorage.clearWithoutNotify();
       },
+      storage: options.storage,
     });
   } else {
     const secretSeed = options.crypto.newRandomSecretSeed();
@@ -257,6 +266,7 @@ export async function createJazzContext<
       onLogOut: async () => {
         await authSecretStorage.clearWithoutNotify();
       },
+      storage: options.storage,
     });
 
     if (!options.newAccountProps) {
@@ -278,9 +288,11 @@ export async function createJazzContext<
 export function createAnonymousJazzContext({
   peersToLoadFrom,
   crypto,
+  storage,
 }: {
   peersToLoadFrom: Peer[];
   crypto: CryptoProvider;
+  storage?: StorageAPI;
 }): JazzContextWithAgent {
   const agentSecret = crypto.newRandomAgentSecret();
 
@@ -294,6 +306,10 @@ export function createAnonymousJazzContext({
     node.syncManager.addPeer(peer);
   }
 
+  if (storage) {
+    node.setStorage(storage);
+  }
+
   activeAccountContext.setGuestMode();
 
   return {

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

@@ -7,22 +7,24 @@ import { z } from "../zodReExport.js";
 import { Loaded, ResolveQuery } from "../zodSchema.js";
 import { AnyCoMapSchema, CoMapSchema } from "./CoMapSchema.js";
 
+export type BaseProfileShape = {
+  name: z.core.$ZodString<string>;
+  inbox?: z.core.$ZodOptional<z.core.$ZodString>;
+  inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
+};
+
+export type BaseAccountShape = {
+  profile: AnyCoMapSchema<BaseProfileShape>;
+  root: AnyCoMapSchema;
+};
+
+export type DefaultAccountShape = {
+  profile: CoMapSchema<BaseProfileShape>;
+  root: CoMapSchema<{}>;
+};
+
 export type AccountSchema<
-  Shape extends {
-    profile: AnyCoMapSchema<{
-      name: z.core.$ZodString<string>;
-      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
-      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
-    }>;
-    root: AnyCoMapSchema;
-  } = {
-    profile: CoMapSchema<{
-      name: z.core.$ZodString<string>;
-      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
-      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
-    }>;
-    root: CoMapSchema<{}>;
-  },
+  Shape extends BaseAccountShape = DefaultAccountShape,
 > = Omit<CoMapSchema<Shape>, "create" | "load" | "withMigration"> & {
   builtin: "Account";
 

package/src/tools/implementation/zodSchema/zodCo.ts

@@ -1,22 +1,23 @@
 import {
   type Account,
-  AccountCreationProps,
-  AccountSchema,
-  AnyCoMapSchema,
+  type AccountCreationProps,
+  type AccountSchema,
+  type AnyCoMapSchema,
+  BaseAccountShape,
   CoFeed,
-  CoFeedSchema,
-  CoListSchema,
-  CoMapSchema,
+  type CoFeedSchema,
+  type CoListSchema,
+  type CoMapSchema,
   CoPlainText,
-  CoProfileSchema,
-  CoRecordSchema,
+  type CoProfileSchema,
+  type CoRecordSchema,
   CoRichText,
-  DefaultProfileShape,
+  type DefaultProfileShape,
   FileStream,
-  FileStreamSchema,
+  type FileStreamSchema,
   ImageDefinition,
-  PlainTextSchema,
-  Simplify,
+  type PlainTextSchema,
+  type Simplify,
   zodSchemaToCoSchema,
 } from "../../internal.js";
 import { RichTextSchema } from "./schemaTypes/RichTextSchema.js";
@@ -82,16 +83,9 @@ export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
   return enrichCoMapSchema(objectSchema);
 };
 
-function enrichAccountSchema<
-  Shape extends {
-    profile: AnyCoMapSchema<{
-      name: z.core.$ZodString<string>;
-      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
-      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
-    }>;
-    root: AnyCoMapSchema;
-  },
->(schema: z.ZodObject<Shape, z.core.$strip>) {
+function enrichAccountSchema<Shape extends BaseAccountShape>(
+  schema: z.ZodObject<Shape, z.core.$strip>,
+) {
   const enrichedSchema = Object.assign(schema, {
     collaborative: true,
     builtin: "Account",
@@ -142,16 +136,44 @@ function enrichAccountSchema<
   return enrichedSchema;
 }
 
-export const coAccountDefiner = <
-  Shape extends {
-    profile: AnyCoMapSchema<{
-      name: z.core.$ZodString<string>;
-      inbox?: z.core.$ZodOptional<z.core.$ZodString>;
-      inboxInvite?: z.core.$ZodOptional<z.core.$ZodString>;
-    }>;
-    root: AnyCoMapSchema;
-  },
->(
+/**
+ * Defines a collaborative account schema for Jazz applications.
+ *
+ * Creates an account schema that represents a user account with profile and root data.
+ * Accounts are the primary way to identify and manage users in Jazz applications.
+ *
+ * @template Shape - The shape of the account schema extending BaseAccountShape
+ * @param shape - The account schema shape. Defaults to a basic profile with name, inbox, and inboxInvite fields, plus an empty root object.
+ *
+ * @example
+ * ```typescript
+ * // Basic account with default profile
+ * const BasicAccount = co.account();
+ *
+ * // Custom account with specific profile and root structure
+ * const JazzAccount = co.account({
+ *   profile: co.profile({
+ *     name: z.string(),
+ *     avatar: z.optional(z.string()),
+ *   }),
+ *   root: co.map({
+ *     organizations: co.list(Organization),
+ *     draftOrganization: DraftOrganization,
+ *   }),
+ * }).withMigration(async (account) => {
+ *   // Migration logic for existing accounts
+ *   if (account.profile === undefined) {
+ *     const group = Group.create();
+ *     account.profile = co.profile().create(
+ *       { name: getRandomUsername() },
+ *       group
+ *     );
+ *     group.addMember("everyone", "reader");
+ *   }
+ * });
+ * ```
+ */
+export const coAccountDefiner = <Shape extends BaseAccountShape>(
   shape: Shape = {
     profile: coMapDefiner({
       name: z.string(),

package/src/tools/subscribe/SubscriptionScope.ts

@@ -249,6 +249,10 @@ export class SubscriptionScope<D extends CoValue> {
     // If the value is in error, we send the update regardless of the children statuses
     if (this.value.type !== "loaded") return true;
 
+    if (this.isStreaming() && !this.isFileStream()) {
+      return false;
+    }
+
     for (const value of this.childValues.values()) {
       // We don't wait for autoloaded values to be loaded, in order to stream updates
       // on autoloaded lists or records
@@ -285,6 +289,22 @@ export class SubscriptionScope<D extends CoValue> {
     return undefined;
   }
 
+  isStreaming() {
+    if (this.value.type !== "loaded") {
+      return false;
+    }
+
+    return this.value.value._raw.core.verified.isStreaming();
+  }
+
+  isFileStream() {
+    if (this.value.type !== "loaded") {
+      return false;
+    }
+
+    return this.value.value._raw.core.verified.header.meta?.type === "binary";
+  }
+
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
     if (!this.dirty) return;

package/src/tools/testing.ts

@@ -19,7 +19,10 @@ import {
   randomSessionProvider,
 } from "./internal.js";
 
-const syncServer: { current: LocalNode | null } = { current: null };
+const syncServer: { current: LocalNode | null; asyncPeers: boolean } = {
+  current: null,
+  asyncPeers: false,
+};
 
 export class TestJSCrypto extends PureJSCrypto {
   static async create() {
@@ -57,6 +60,23 @@ export function getPeerConnectedToTestSyncServer() {
       peer2role: "server",
     },
   );
+
+  if (syncServer.asyncPeers) {
+    const push = aPeer.outgoing.push;
+
+    aPeer.outgoing.push = (message) => {
+      setTimeout(() => {
+        push.call(aPeer.outgoing, message);
+      });
+    };
+
+    bPeer.outgoing.push = (message) => {
+      setTimeout(() => {
+        push.call(bPeer.outgoing, message);
+      });
+    };
+  }
+
   syncServer.current.syncManager.addPeer(aPeer);
 
   return bPeer;
@@ -283,7 +303,9 @@ export async function linkAccounts(
   await b.waitForAllCoValuesSync();
 }
 
-export async function setupJazzTestSync() {
+export async function setupJazzTestSync({
+  asyncPeers = false,
+}: { asyncPeers?: boolean } = {}) {
   if (syncServer.current) {
     syncServer.current.gracefulShutdown();
   }
@@ -296,6 +318,7 @@ export async function setupJazzTestSync() {
   });
 
   syncServer.current = account._raw.core.node;
+  syncServer.asyncPeers = asyncPeers;
 
   return account;
 }