jazz-tools 0.8.50 → 0.9.0

package/src/coValues/coFeed.ts

@@ -32,6 +32,7 @@ import {
   inspect,
   isRefEncoded,
   loadCoValue,
+  parseCoValueCreateOptions,
   subscribeToCoValue,
   subscribeToExistingCoValue,
 } from "../internal.js";
@@ -204,10 +205,11 @@ export class CoFeed<Item = any> extends CoValueBase implements CoValue {
   static create<S extends CoFeed>(
     this: CoValueClass<S>,
     init: S extends CoFeed<infer Item> ? UnCo<Item>[] : never,
-    options: { owner: Account | Group },
+    options: { owner: Account | Group } | Account | Group,
   ) {
-    const instance = new this({ init, owner: options.owner });
-    const raw = options.owner._raw.createStream();
+    const { owner } = parseCoValueCreateOptions(options);
+    const instance = new this({ init, owner });
+    const raw = owner._raw.createStream();
 
     Object.defineProperties(instance, {
       id: {
@@ -673,9 +675,9 @@ export class FileStream extends CoValueBase implements CoValue {
 
   static create<S extends FileStream>(
     this: CoValueClass<S>,
-    options: { owner: Account | Group },
+    options: { owner: Account | Group } | Account | Group,
   ) {
-    return new this(options);
+    return new this(parseCoValueCreateOptions(options));
   }
 
   getChunks(options?: {
@@ -735,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);
@@ -762,12 +764,16 @@ export class FileStream extends CoValueBase implements CoValue {
    */
   static async createFromBlob(
     blob: Blob | File,
-    options: {
-      owner: Group | Account;
-      onProgress?: (progress: number) => void;
-    },
+    options:
+      | {
+          owner: Group | Account;
+          onProgress?: (progress: number) => void;
+        }
+      | Account
+      | Group,
   ): Promise<FileStream> {
-    const stream = this.create({ owner: options.owner });
+    const stream = this.create(options);
+    const onProgress = "onProgress" in options ? options.onProgress : undefined;
 
     const start = Date.now();
 
@@ -785,7 +791,7 @@ export class FileStream extends CoValueBase implements CoValue {
       stream.push(data.slice(idx, idx + chunkSize));
 
       if (Date.now() - lastProgressUpdate > 100) {
-        options.onProgress?.(idx / data.length);
+        onProgress?.(idx / data.length);
         lastProgressUpdate = Date.now();
       }
 
@@ -800,7 +806,7 @@ export class FileStream extends CoValueBase implements CoValue {
       "s - Throughput in MB/s",
       (1000 * (blob.size / (end - start))) / (1024 * 1024),
     );
-    options.onProgress?.(1);
+    onProgress?.(1);
 
     return stream;
   }

package/src/coValues/coList.ts

@@ -23,6 +23,7 @@ import {
   isRefEncoded,
   loadCoValue,
   makeRefs,
+  parseCoValueCreateOptions,
   subscribeToCoValue,
   subscribeToExistingCoValue,
   subscriptionsScopes,
@@ -220,10 +221,11 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
   static create<L extends CoList>(
     this: CoValueClass<L>,
     items: UnCo<L[number]>[],
-    options: { owner: Account | Group },
+    options: { owner: Account | Group } | Account | Group,
   ) {
-    const instance = new this({ init: items, owner: options.owner });
-    const raw = options.owner._raw.createList(
+    const { owner } = parseCoValueCreateOptions(options);
+    const instance = new this({ init: items, owner });
+    const raw = owner._raw.createList(
       toRawItems(items, instance._schema[ItemsSym]),
     );
 
@@ -239,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/coMap.ts

@@ -30,6 +30,7 @@ import {
   isRefEncoded,
   loadCoValue,
   makeRefs,
+  parseCoValueCreateOptions,
   subscribeToCoValue,
   subscribeToExistingCoValue,
   subscriptionsScopes,
@@ -43,6 +44,7 @@ type CoMapEdit<V> = {
   ref?: RefIfCoValue<V>;
   by?: Account;
   madeAt: Date;
+  key?: string;
 };
 
 type LastAndAllCoMapEdits<V> = CoMapEdit<V> & { all: CoMapEdit<V>[] };
@@ -183,6 +185,7 @@ export class CoMap extends CoValueBase implements CoValue {
           optional: false,
         }).accessFrom(target, "_edits." + key + ".by"),
       madeAt: rawEdit.at,
+      key,
     };
   }
 
@@ -271,17 +274,19 @@ export class CoMap extends CoValueBase implements CoValue {
   static create<M extends CoMap>(
     this: CoValueClass<M>,
     init: Simplify<CoMapInit<M>>,
-    options: {
-      owner: Account | Group;
-      unique?: CoValueUniqueness["uniqueness"];
-    },
+    options:
+      | {
+          owner: Account | Group;
+          unique?: CoValueUniqueness["uniqueness"];
+        }
+      | Account
+      | Group,
   ) {
     const instance = new this();
-    const raw = instance.rawFromInit(
-      init,
-      options.owner,
-      options.unique === undefined ? undefined : { uniqueness: options.unique },
-    );
+
+    const { owner, uniqueness } = parseCoValueCreateOptions(options);
+    const raw = instance.rawFromInit(init, owner, uniqueness);
+
     Object.defineProperties(instance, {
       id: {
         value: raw.id,

package/src/coValues/group.ts

@@ -14,6 +14,7 @@ import {
   Ref,
   ensureCoValueLoaded,
   loadCoValue,
+  parseCoValueCreateOptions,
   subscribeToCoValue,
   subscribeToExistingCoValue,
 } from "../internal.js";
@@ -123,9 +124,9 @@ export class Group extends CoValueBase implements CoValue {
 
   static create<G extends Group>(
     this: CoValueClass<G>,
-    options: { owner: Account },
+    options: { owner: Account } | Account,
   ) {
-    return new this(options);
+    return new this(parseCoValueCreateOptions(options));
   }
 
   myRole(): Role | undefined {

package/src/coValues/interfaces.ts

@@ -1,4 +1,8 @@
-import type { CojsonInternalTypes, RawCoValue } from "cojson";
+import type {
+  CoValueUniqueness,
+  CojsonInternalTypes,
+  RawCoValue,
+} from "cojson";
 import { RawAccount } from "cojson";
 import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
 import type { DeeplyLoaded, DepthsIn } from "../internal.js";
@@ -157,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();
       },
     );
   });
@@ -191,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;
@@ -229,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;
 
@@ -253,6 +270,7 @@ export function createCoValueObservable<V extends CoValue, Depth>() {
         listener();
       },
       onUnavailable,
+      options?.syncResolution,
     );
 
     return () => {
@@ -285,3 +303,21 @@ export function subscribeToExistingCoValue<V extends CoValue, Depth>(
     listener,
   );
 }
+
+export function parseCoValueCreateOptions(
+  options:
+    | {
+        owner: Account | Group;
+        unique?: CoValueUniqueness["uniqueness"];
+      }
+    | Account
+    | Group,
+) {
+  return "_type" in options &&
+    (options._type === "Account" || options._type === "Group")
+    ? { owner: options, uniqueness: undefined }
+    : {
+        owner: options.owner,
+        uniqueness: options.unique ? { uniqueness: options.unique } : undefined,
+      };
+}

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/coFeed.test.ts

@@ -4,6 +4,7 @@ import {
   Account,
   CoFeed,
   FileStream,
+  Group,
   ID,
   WasmCrypto,
   co,
@@ -34,6 +35,21 @@ describe("Simple CoFeed operations", async () => {
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
+  test("Construction with an Account", () => {
+    const stream = TestStream.create(["milk"], me);
+
+    expect(stream[me.id]?.value).toEqual("milk");
+    expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
+  });
+
+  test("Construction with a Group", () => {
+    const group = Group.create(me);
+    const stream = TestStream.create(["milk"], group);
+
+    expect(stream[me.id]?.value).toEqual("milk");
+    expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
+  });
+
   describe("Mutation", () => {
     test("pushing", () => {
       stream.push("bread");

package/src/tests/coList.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from "vitest";
 import {
   Account,
   CoList,
+  Group,
   WasmCrypto,
   co,
   cojsonInternals,
@@ -37,6 +38,19 @@ describe("Simple CoList operations", async () => {
     ]);
   });
 
+  test("Construction with an Account", () => {
+    const list = TestList.create(["milk"], me);
+
+    expect(list[0]).toEqual("milk");
+  });
+
+  test("Construction with a Group", () => {
+    const group = Group.create(me);
+    const list = TestList.create(["milk"], group);
+
+    expect(list[0]).toEqual("milk");
+  });
+
   describe("Mutation", () => {
     test("assignment", () => {
       const list = TestList.create(["bread", "butter", "onion"], {

package/src/tests/coMap.test.ts

@@ -64,6 +64,25 @@ describe("Simple CoMap operations", async () => {
     ]);
   });
 
+  test("Construction with an Account", () => {
+    const map = TestMap.create(
+      { color: "red", _height: 10, birthday: birthday },
+      me,
+    );
+
+    expect(map.color).toEqual("red");
+  });
+
+  test("Construction with a Group", () => {
+    const group = Group.create(me);
+    const map = TestMap.create(
+      { color: "red", _height: 10, birthday: birthday },
+      group,
+    );
+
+    expect(map.color).toEqual("red");
+  });
+
   test("Construction with too many things provided", () => {
     const mapWithExtra = TestMap.create(
       {

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),
     );
   });