jazz-tools 0.8.51 → 0.9.0

package/src/coValues/coFeed.ts

@@ -737,7 +737,7 @@ export class FileStream extends CoValueBase implements CoValue {
      */
     if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
       stream = await new Promise<FileStream>((resolve) => {
-        const unsubscribe = subscribeToCoValue(this, id, as, [], (value) => {
+        subscribeToCoValue(this, id, as, [], (value, unsubscribe) => {
           if (value.isBinaryStreamEnded()) {
             unsubscribe();
             resolve(value);

package/src/coValues/coList.ts

@@ -241,9 +241,11 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   }
 
   push(...items: Item[]): number {
-    for (const item of toRawItems(items as Item[], this._schema[ItemsSym])) {
-      this._raw.append(item);
-    }
+    this._raw.appendItems(
+      toRawItems(items, this._schema[ItemsSym]),
+      undefined,
+      "private",
+    );
 
     return this._raw.entries().length;
   }

package/src/coValues/interfaces.ts

@@ -161,18 +161,17 @@ export function loadCoValue<V extends CoValue, Depth>(
   depth: Depth & DepthsIn<V>,
 ): Promise<DeeplyLoaded<V, Depth> | undefined> {
   return new Promise((resolve) => {
-    const unsubscribe = subscribeToCoValue(
+    subscribeToCoValue(
       cls,
       id,
       as,
       depth,
-      (value) => {
+      (value, unsubscribe) => {
         resolve(value);
         unsubscribe();
       },
       () => {
         resolve(undefined);
-        unsubscribe();
       },
     );
   });
@@ -195,37 +194,49 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
   id: ID<V>,
   as: Account | AnonymousJazzAgent,
   depth: Depth & DepthsIn<V>,
-  listener: (value: DeeplyLoaded<V, Depth>) => void,
+  listener: (value: DeeplyLoaded<V, Depth>, unsubscribe: () => void) => void,
   onUnavailable?: () => void,
+  syncResolution?: boolean,
 ): () => void {
   const ref = new Ref(id, as, { ref: cls, optional: false });
 
   let unsubscribed = false;
   let unsubscribe: (() => void) | undefined;
 
-  ref
-    .load()
-    .then((value) => {
-      if (!value) {
-        onUnavailable && onUnavailable();
-        return;
-      }
-      if (unsubscribed) return;
-      const subscription = new SubscriptionScope(
-        value,
-        cls as CoValueClass<V> & CoValueFromRaw<V>,
-        (update) => {
-          if (fulfillsDepth(depth, update)) {
-            listener(update as DeeplyLoaded<V, Depth>);
-          }
-        },
-      );
+  function subscribe(value: V | undefined) {
+    if (!value) {
+      onUnavailable && onUnavailable();
+      return;
+    }
+    if (unsubscribed) return;
+    const subscription = new SubscriptionScope(
+      value,
+      cls as CoValueClass<V> & CoValueFromRaw<V>,
+      (update, subscription) => {
+        if (fulfillsDepth(depth, update)) {
+          listener(
+            update as DeeplyLoaded<V, Depth>,
+            subscription.unsubscribeAll,
+          );
+        }
+      },
+    );
 
-      unsubscribe = () => subscription.unsubscribeAll();
-    })
-    .catch((e) => {
-      console.error("Failed to load / subscribe to CoValue", e);
-    });
+    unsubscribe = subscription.unsubscribeAll;
+  }
+
+  const sync = syncResolution ? ref.syncLoad() : undefined;
+
+  if (sync) {
+    subscribe(sync);
+  } else {
+    ref
+      .load()
+      .then((value) => subscribe(value))
+      .catch((e) => {
+        console.error("Failed to load / subscribe to CoValue", e);
+      });
+  }
 
   return function unsubscribeAtAnyPoint() {
     unsubscribed = true;
@@ -233,7 +244,9 @@ export function subscribeToCoValue<V extends CoValue, Depth>(
   };
 }
 
-export function createCoValueObservable<V extends CoValue, Depth>() {
+export function createCoValueObservable<V extends CoValue, Depth>(options?: {
+  syncResolution?: boolean;
+}) {
   let currentValue: DeeplyLoaded<V, Depth> | undefined = undefined;
   let subscriberCount = 0;
 
@@ -257,6 +270,7 @@ export function createCoValueObservable<V extends CoValue, Depth>() {
         listener();
       },
       onUnavailable,
+      options?.syncResolution,
     );
 
     return () => {

package/src/implementation/refs.ts

@@ -55,6 +55,23 @@ export class Ref<out V extends CoValue> {
     }
   }
 
+  syncLoad(): V | undefined {
+    const node =
+      "node" in this.controlledAccount
+        ? this.controlledAccount.node
+        : this.controlledAccount._raw.core.node;
+
+    const entry = node.coValuesStore.get(
+      this.id as unknown as CoID<RawCoValue>,
+    );
+
+    if (entry.state.type === "available") {
+      return new Ref(this.id, this.controlledAccount, this.schema).value!;
+    }
+
+    return undefined;
+  }
+
   async load(): Promise<V | undefined> {
     const result = await this.loadHelper();
     if (result === "unavailable") {

package/src/implementation/subscriptionScope.ts

@@ -37,7 +37,7 @@ export class SubscriptionScope<Root extends CoValue> {
   constructor(
     root: Root,
     rootSchema: CoValueClass<Root> & CoValueFromRaw<Root>,
-    onUpdate: (newRoot: Root) => void,
+    onUpdate: (newRoot: Root, scope: SubscriptionScope<Root>) => void,
   ) {
     this.rootEntry = {
       state: "loaded" as const,
@@ -52,7 +52,7 @@ export class SubscriptionScope<Root extends CoValue> {
     this.scheduleUpdate = () => {
       const value = rootSchema.fromRaw(this.rootEntry.value) as Root;
       subscriptionsScopes.set(value, this);
-      onUpdate(value);
+      onUpdate(value, this);
     };
 
     this.rootEntry.rawUnsub = root._raw.core.subscribe(
@@ -125,7 +125,7 @@ export class SubscriptionScope<Root extends CoValue> {
     }
   }
 
-  unsubscribeAll() {
+  unsubscribeAll = () => {
     for (const entry of this.entries.values()) {
       if (entry.state === "loaded") {
         entry.rawUnsub();
@@ -134,5 +134,5 @@ export class SubscriptionScope<Root extends CoValue> {
       }
     }
     this.entries.clear();
-  }
+  };
 }

package/src/testing.ts

@@ -0,0 +1,103 @@
+import { AgentSecret, CryptoProvider, Peer } from "cojson";
+import { cojsonInternals } from "cojson";
+import { PureJSCrypto } from "cojson/crypto";
+import { Account, type AccountClass } from "./exports.js";
+import {
+  type AnonymousJazzAgent,
+  type CoValueClass,
+  createAnonymousJazzContext,
+} from "./internal.js";
+
+type TestAccountSchema<Acc extends Account> = CoValueClass<Acc> & {
+  fromNode: (typeof Account)["fromNode"];
+  create: (options: {
+    creationProps: { name: string };
+    initialAgentSecret?: AgentSecret;
+    peersToLoadFrom?: Peer[];
+    crypto: CryptoProvider;
+  }) => Promise<Acc>;
+};
+
+class TestJSCrypto extends PureJSCrypto {
+  static async create() {
+    if ("navigator" in globalThis && navigator.userAgent.includes("jsdom")) {
+      // Mocking crypto seal & encrypt to make it work with JSDom. Getting "Error: Uint8Array expected" there
+      const crypto = new PureJSCrypto();
+
+      crypto.seal = (options) =>
+        `sealed_U${cojsonInternals.stableStringify(options.message)}` as any;
+      crypto.unseal = (sealed) =>
+        JSON.parse(sealed.substring("sealed_U".length));
+      crypto.encrypt = (message) =>
+        `encrypted_U${cojsonInternals.stableStringify(message)}` as any;
+      crypto.decryptRaw = (encrypted) =>
+        encrypted.substring("encrypted_U".length) as any;
+
+      return crypto;
+    }
+
+    // For non-jsdom environments, we use the real crypto
+    return new PureJSCrypto();
+  }
+}
+
+export async function createJazzTestAccount<Acc extends Account>(options?: {
+  AccountSchema?: CoValueClass<Acc>;
+}): Promise<Acc> {
+  const AccountSchema = (options?.AccountSchema ??
+    Account) as unknown as TestAccountSchema<Acc>;
+  const account = await AccountSchema.create({
+    creationProps: {
+      name: "Test Account",
+    },
+    crypto: await TestJSCrypto.create(),
+  });
+
+  return account;
+}
+
+export async function createJazzTestGuest() {
+  const ctx = await createAnonymousJazzContext({
+    crypto: await PureJSCrypto.create(),
+    peersToLoadFrom: [],
+  });
+
+  return {
+    guest: ctx.agent,
+  };
+}
+
+export function getJazzContextShape<Acc extends Account>(
+  account: Acc | { guest: AnonymousJazzAgent },
+) {
+  if ("guest" in account) {
+    return {
+      guest: account.guest,
+      AccountSchema: Account,
+      logOut: () => account.guest.node.gracefulShutdown(),
+      done: () => account.guest.node.gracefulShutdown(),
+    };
+  }
+
+  return {
+    me: account,
+    AccountSchema: account.constructor as AccountClass<Acc>,
+    logOut: () => account._raw.core.node.gracefulShutdown(),
+    done: () => account._raw.core.node.gracefulShutdown(),
+  };
+}
+
+export function linkAccounts(
+  a: Account,
+  b: Account,
+  aRole: "server" | "client" = "server",
+  bRole: "server" | "client" = "server",
+) {
+  const [aPeer, bPeer] = cojsonInternals.connectedPeers(b.id, a.id, {
+    peer1role: aRole,
+    peer2role: bRole,
+  });
+
+  a._raw.core.node.syncManager.addPeer(aPeer);
+  b._raw.core.node.syncManager.addPeer(bPeer);
+}

package/src/tests/schemaUnion.test.ts

@@ -99,6 +99,7 @@ describe("SchemaUnion", () => {
       { type: "button", label: "Submit" },
       { owner: me },
     );
+    let currentValue = "Submit";
     const unsubscribe = subscribeToCoValue(
       WidgetUnion,
       buttonWidget.id,
@@ -106,13 +107,16 @@ describe("SchemaUnion", () => {
       {},
       (value: BaseWidget) => {
         if (value instanceof ButtonWidget) {
-          expect(value.label).toBe("Changed");
-          unsubscribe();
+          expect(value.label).toBe(currentValue);
         } else {
           throw new Error("Unexpected widget type");
         }
       },
+      () => {},
+      true,
     );
+    currentValue = "Changed";
     buttonWidget.label = "Changed";
+    unsubscribe();
   });
 });

package/src/tests/subscribe.test.ts

@@ -1,9 +1,15 @@
 import { describe, expect, it, onTestFinished, vi } from "vitest";
-import { Account, CoFeed, CoList, CoMap, co } from "../index.web.js";
 import {
-  type DepthsIn,
+  Account,
+  CoFeed,
+  CoList,
+  CoMap,
   FileStream,
   Group,
+  co,
+} from "../index.web.js";
+import {
+  type DepthsIn,
   createCoValueObservable,
   subscribeToCoValue,
 } from "../internal.js";
@@ -64,6 +70,7 @@ describe("subscribeToCoValue", () => {
         messages: null,
         name: "General",
       }),
+      expect.any(Function),
     );
 
     updateFn.mockClear();
@@ -78,6 +85,7 @@ describe("subscribeToCoValue", () => {
         name: "General",
         messages: expect.any(Array),
       }),
+      expect.any(Function),
     );
 
     updateFn.mockClear();
@@ -93,6 +101,7 @@ describe("subscribeToCoValue", () => {
         name: "Lounge",
         messages: expect.any(Array),
       }),
+      expect.any(Function),
     );
   });
 
@@ -125,6 +134,7 @@ describe("subscribeToCoValue", () => {
         name: "General",
         messages: expect.any(Array),
       }),
+      expect.any(Function),
     );
   });
 

package/src/tests/utils.ts

@@ -1,7 +1,7 @@
 import { isControlledAccount } from "../coValues/account";
 
 import { CoID, LocalNode, RawCoValue } from "cojson";
-import { connectedPeers } from "cojson/src/streamUtils.js";
+import { cojsonInternals } from "cojson";
 import {
   Account,
   WasmCrypto,
@@ -18,10 +18,14 @@ export async function setupAccount() {
     crypto: Crypto,
   });
 
-  const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
-    peer1role: "server",
-    peer2role: "client",
-  });
+  const [initialAsPeer, secondPeer] = cojsonInternals.connectedPeers(
+    "initial",
+    "second",
+    {
+      peer1role: "server",
+      peer2role: "client",
+    },
+  );
 
   if (!isControlledAccount(me)) {
     throw "me is not a controlled account";
@@ -41,7 +45,7 @@ export async function setupAccount() {
 }
 
 export async function setupTwoNodes() {
-  const [serverAsPeer, clientAsPeer] = connectedPeers(
+  const [serverAsPeer, clientAsPeer] = cojsonInternals.connectedPeers(
     "clientToServer",
     "serverToClient",
     {

package/tsup.config.ts

@@ -4,6 +4,7 @@ export default defineConfig({
   entry: {
     "index.web": "src/index.web.ts",
     "index.native": "src/index.native.ts",
+    testing: "src/testing.ts",
   },
   format: ["esm"],
   dts: false,