jazz-tools 0.9.1 → 0.9.9

package/src/coValues/group.ts

@@ -13,9 +13,9 @@ import {
   MembersSym,
   Ref,
   ensureCoValueLoaded,
-  loadCoValue,
-  parseCoValueCreateOptions,
-  subscribeToCoValue,
+  loadCoValueWithoutMe,
+  parseGroupCreateOptions,
+  subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
 import { AccountAndGroupProxyHandler, isControlledAccount } from "./account.js";
@@ -124,9 +124,9 @@ export class Group extends CoValueBase implements CoValue {
 
   static create<G extends Group>(
     this: CoValueClass<G>,
-    options: { owner: Account } | Account,
+    options?: { owner: Account } | Account,
   ) {
-    return new this(parseCoValueCreateOptions(options));
+    return new this(parseGroupCreateOptions(options));
   }
 
   myRole(): Role | undefined {
@@ -179,24 +179,56 @@ export class Group extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  static load<G extends Group, Depth>(
-    this: CoValueClass<G>,
-    id: ID<G>,
+  static load<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
+    depth: Depth & DepthsIn<C>,
+  ): Promise<DeeplyLoaded<C, Depth> | undefined>;
+  static load<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
     as: Account,
-    depth: Depth & DepthsIn<G>,
-  ): Promise<DeeplyLoaded<G, Depth> | undefined> {
-    return loadCoValue(this, id, as, depth);
+    depth: Depth & DepthsIn<C>,
+  ): Promise<DeeplyLoaded<C, Depth> | undefined>;
+  static load<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
+    asOrDepth: Account | (Depth & DepthsIn<C>),
+    depth?: Depth & DepthsIn<C>,
+  ): Promise<DeeplyLoaded<C, Depth> | undefined> {
+    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
   }
 
   /** @category Subscription & Loading */
-  static subscribe<G extends Group, Depth>(
-    this: CoValueClass<G>,
-    id: ID<G>,
+  static subscribe<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
+    depth: Depth & DepthsIn<C>,
+    listener: (value: DeeplyLoaded<C, Depth>) => void,
+  ): () => void;
+  static subscribe<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
     as: Account,
-    depth: Depth & DepthsIn<G>,
-    listener: (value: DeeplyLoaded<G, Depth>) => void,
+    depth: Depth & DepthsIn<C>,
+    listener: (value: DeeplyLoaded<C, Depth>) => void,
+  ): () => void;
+  static subscribe<C extends Group, Depth>(
+    this: CoValueClass<C>,
+    id: ID<C>,
+    asOrDepth: Account | (Depth & DepthsIn<C>),
+    depthOrListener:
+      | (Depth & DepthsIn<C>)
+      | ((value: DeeplyLoaded<C, Depth>) => void),
+    listener?: (value: DeeplyLoaded<C, Depth>) => void,
   ): () => void {
-    return subscribeToCoValue<G, Depth>(this, id, as, depth, listener);
+    return subscribeToCoValueWithoutMe<C, Depth>(
+      this,
+      id,
+      asOrDepth,
+      depthOrListener,
+      listener,
+    );
   }
 
   /** @category Subscription & Loading */

package/src/coValues/inbox.ts

@@ -7,6 +7,7 @@ import {
   SessionID,
 } from "cojson";
 import { CoStreamItem, RawCoStream } from "cojson";
+import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { type Account } from "./account.js";
 import { CoValue, CoValueClass, ID, loadCoValue } from "./interfaces.js";
 
@@ -312,7 +313,9 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
   static async load<
     I extends CoValue,
     O extends CoValue | undefined = undefined,
-  >(inboxOwnerID: ID<Account>, currentAccount: Account) {
+  >(inboxOwnerID: ID<Account>, currentAccount?: Account) {
+    currentAccount ||= activeAccountContext.get();
+
     const node = currentAccount._raw.core.node;
 
     const inboxOwnerRaw = await node.load(
@@ -347,7 +350,9 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
   }
 }
 
-async function acceptInvite(invite: string, account: Account) {
+async function acceptInvite(invite: string, account?: Account) {
+  account ||= activeAccountContext.get();
+
   const id = invite.slice(0, invite.indexOf("/")) as CoID<MessagesStream>;
 
   const inviteSecret = invite.slice(invite.indexOf("/") + 1) as InviteSecret;

package/src/coValues/interfaces.ts

@@ -4,6 +4,7 @@ import type {
   RawCoValue,
 } from "cojson";
 import { RawAccount } from "cojson";
+import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
 import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
@@ -154,6 +155,24 @@ export class CoValueBase implements CoValue {
   }
 }
 
+export function loadCoValueWithoutMe<V extends CoValue, Depth>(
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
+  depth?: Depth & DepthsIn<V>,
+) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (!depth) {
+      throw new Error(
+        "Depth is required when loading a CoValue as an Account or AnonymousJazzAgent",
+      );
+    }
+    return loadCoValue(cls, id, asOrDepth, depth);
+  }
+
+  return loadCoValue(cls, id, activeAccountContext.get(), asOrDepth);
+}
+
 export function loadCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
   id: ID<V>,
@@ -189,6 +208,41 @@ export function ensureCoValueLoaded<V extends CoValue, Depth>(
   );
 }
 
+export function subscribeToCoValueWithoutMe<V extends CoValue, Depth>(
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
+  depthOrListener:
+    | (Depth & DepthsIn<V>)
+    | ((value: DeeplyLoaded<V, Depth>) => void),
+  listener?: (value: DeeplyLoaded<V, Depth>) => void,
+) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (typeof depthOrListener !== "function") {
+      return subscribeToCoValue<V, Depth>(
+        cls,
+        id,
+        asOrDepth,
+        depthOrListener,
+        listener!,
+      );
+    }
+    throw new Error("Invalid arguments");
+  }
+
+  if (typeof depthOrListener !== "function") {
+    throw new Error("Invalid arguments");
+  }
+
+  return subscribeToCoValue<V, Depth>(
+    cls,
+    id,
+    activeAccountContext.get(),
+    asOrDepth,
+    depthOrListener,
+  );
+}
+
 export function subscribeToCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
   id: ID<V>,
@@ -304,20 +358,69 @@ export function subscribeToExistingCoValue<V extends CoValue, Depth>(
   );
 }
 
+export function isAccountInstance(instance: unknown): instance is Account {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+
+  return "_type" in instance && instance._type === "Account";
+}
+
+export function isAnonymousAgentInstance(
+  instance: unknown,
+): instance is AnonymousJazzAgent {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+
+  return "_type" in instance && instance._type === "Anonymous";
+}
+
 export function parseCoValueCreateOptions(
   options:
     | {
-        owner: Account | Group;
+        owner?: Account | Group;
         unique?: CoValueUniqueness["uniqueness"];
       }
     | Account
-    | Group,
+    | Group
+    | undefined,
 ) {
-  return "_type" in options &&
-    (options._type === "Account" || options._type === "Group")
-    ? { owner: options, uniqueness: undefined }
-    : {
-        owner: options.owner,
-        uniqueness: options.unique ? { uniqueness: options.unique } : undefined,
-      };
+  const Group = RegisteredSchemas["Group"];
+
+  if (!options) {
+    return { owner: Group.create(), uniqueness: undefined };
+  }
+
+  if ("_type" in options) {
+    if (options._type === "Account" || options._type === "Group") {
+      return { owner: options, uniqueness: undefined };
+    }
+  }
+
+  const uniqueness = options.unique
+    ? { uniqueness: options.unique }
+    : undefined;
+
+  return {
+    owner: options.owner ?? Group.create(),
+    uniqueness,
+  };
+}
+
+export function parseGroupCreateOptions(
+  options:
+    | {
+        owner?: Account;
+      }
+    | Account
+    | undefined,
+) {
+  if (!options) {
+    return { owner: activeAccountContext.get() };
+  }
+
+  return "_type" in options && isAccountInstance(options)
+    ? { owner: options }
+    : { owner: options.owner ?? activeAccountContext.get() };
 }

package/src/exports.ts

@@ -12,27 +12,32 @@ export type { CoValue, ID } from "./internal.js";
 
 export { Encoders, co } from "./internal.js";
 
-export {
-  Inbox,
-  InboxSender,
-} from "./coValues/inbox.js";
+export { Inbox, InboxSender } from "./coValues/inbox.js";
 
 export {
   Account,
   isControlledAccount,
   type AccountClass,
 } from "./coValues/account.js";
-export { Group } from "./coValues/group.js";
 export {
-  CoStream,
+  BinaryCoStream,
   CoFeed,
+  CoStream,
   FileStream,
-  BinaryCoStream,
 } from "./coValues/coFeed.js";
 export { CoList } from "./coValues/coList.js";
 export { CoMap, type CoMapInit } from "./coValues/coMap.js";
-export { CoValueBase } from "./coValues/interfaces.js";
+export { CoPlainText, type TextPos } from "./coValues/coPlainText.js";
+export {
+  CoRichText,
+  Marks,
+  type TreeLeaf,
+  type TreeNode,
+  type ResolvedMark,
+} from "./coValues/coRichText.js";
 export { ImageDefinition } from "./coValues/extensions/imageDef.js";
+export { Group } from "./coValues/group.js";
+export { CoValueBase } from "./coValues/interfaces.js";
 export { Profile } from "./coValues/profile.js";
 export { SchemaUnion } from "./coValues/schemaUnion.js";
 

package/src/implementation/activeAccountContext.ts

@@ -0,0 +1,33 @@
+import type { Account } from "../coValues/account.js";
+
+class ActiveAccountContext {
+  private activeAccount: Account | null = null;
+  private guestMode: boolean = false;
+
+  set(account: Account) {
+    this.activeAccount = account;
+    this.guestMode = false;
+  }
+
+  setGuestMode() {
+    this.guestMode = true;
+  }
+
+  get() {
+    if (!this.activeAccount) {
+      if (this.guestMode) {
+        throw new Error(
+          "Something that expects a full active account was called in guest mode.",
+        );
+      }
+
+      throw new Error("No active account");
+    }
+
+    return this.activeAccount;
+  }
+}
+
+export type { ActiveAccountContext };
+
+export const activeAccountContext = new ActiveAccountContext();

package/src/implementation/createContext.ts

@@ -12,6 +12,7 @@ import {
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import type { ID } from "../internal.js";
+import { activeAccountContext } from "./activeAccountContext.js";
 import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 
 export type Credentials = {
@@ -169,11 +170,14 @@ export async function createJazzContext<Acc extends Account>(
                 fromRaw: rawAccount,
               }) as Acc;
 
+              activeAccountContext.set(account);
+
               await account.applyMigration(creationProps);
             },
           });
 
           const account = AccountSchema.fromNode(node);
+          activeAccountContext.set(account);
 
           if (authResult.saveCredentials) {
             await authResult.saveCredentials({
@@ -217,12 +221,14 @@ export async function createJazzContext<Acc extends Account>(
             const account = new AccountSchema({
               fromRaw: rawAccount,
             }) as Acc;
+            activeAccountContext.set(account);
 
             await account.applyMigration(creationProps);
           },
         });
 
         const account = AccountSchema.fromNode(node);
+        activeAccountContext.set(account);
 
         await authResult.saveCredentials({
           accountID: node.account.id as unknown as ID<Account>,
@@ -267,6 +273,8 @@ export async function createAnonymousJazzContext({
     node.syncManager.addPeer(peer);
   }
 
+  activeAccountContext.setGuestMode();
+
   return {
     agent: new AnonymousJazzAgent(node),
     done: () => {},

package/src/internal.ts

@@ -1,13 +1,13 @@
-export * from "./implementation/symbols.js";
-export * from "./implementation/inspect.js";
 export * from "./coValues/interfaces.js";
+export * from "./implementation/inspect.js";
+export * from "./implementation/symbols.js";
 
-export * from "./implementation/errors.js";
+export * from "./coValues/deepLoading.js";
 export * from "./implementation/anonymousJazzAgent.js";
+export * from "./implementation/errors.js";
 export * from "./implementation/refs.js";
 export * from "./implementation/schema.js";
 export * from "./implementation/subscriptionScope.js";
-export * from "./coValues/deepLoading.js";
 
 export * from "./implementation/createContext.js";
 

package/src/testing.ts

@@ -2,6 +2,7 @@ import { AgentSecret, CryptoProvider, Peer } from "cojson";
 import { cojsonInternals } from "cojson";
 import { PureJSCrypto } from "cojson/crypto";
 import { Account, type AccountClass } from "./exports.js";
+import { activeAccountContext } from "./implementation/activeAccountContext.js";
 import {
   type AnonymousJazzAgent,
   type CoValueClass,
@@ -42,6 +43,7 @@ class TestJSCrypto extends PureJSCrypto {
 }
 
 export async function createJazzTestAccount<Acc extends Account>(options?: {
+  isCurrentActiveAccount?: boolean;
   AccountSchema?: CoValueClass<Acc>;
 }): Promise<Acc> {
   const AccountSchema = (options?.AccountSchema ??
@@ -52,10 +54,17 @@ export async function createJazzTestAccount<Acc extends Account>(options?: {
     },
     crypto: await TestJSCrypto.create(),
   });
+  if (options?.isCurrentActiveAccount) {
+    activeAccountContext.set(account);
+  }
 
   return account;
 }
 
+export function setActiveAccount(account: Account) {
+  activeAccountContext.set(account);
+}
+
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
     crypto: await PureJSCrypto.create(),

package/src/tests/account.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from "vitest";
 import { CoMap, co } from "../exports.js";
+import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 test("waitForAllCoValuesSync should resolve when all the values are synced", async () => {

package/src/tests/coFeed.test.ts

@@ -14,6 +14,7 @@ import {
   isControlledAccount,
 } from "../index.web.js";
 import { randomSessionProvider } from "../internal.js";
+import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
@@ -499,4 +500,16 @@ describe("waitForSync", async () => {
 
     expect(loadedStream).not.toBe("unavailable");
   });
+
+  test("should rely on the current active account if no account is provided", async () => {
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const stream = FileStream.create();
+    expect(stream._owner._type).toEqual("Group");
+    expect(stream._owner.castAs(Group)._raw.roleOf(account._raw.id)).toEqual(
+      "admin",
+    );
+  });
 });

package/src/tests/coPlainText.test.ts

@@ -0,0 +1,161 @@
+import { connectedPeers } from "cojson/src/streamUtils.js";
+import { describe, expect, test } from "vitest";
+import {
+  Account,
+  CoPlainText,
+  WasmCrypto,
+  cojsonInternals,
+  createJazzContext,
+  fixedCredentialsAuth,
+  isControlledAccount,
+} from "../index.web.js";
+import { randomSessionProvider } from "../internal.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("CoPlainText", () => {
+  const initNodeAndText = async () => {
+    const me = await Account.create({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
+    });
+
+    const text = CoPlainText.create("hello world", { owner: me });
+
+    return { me, text };
+  };
+
+  describe("Simple CoPlainText operations", async () => {
+    const { me, text } = await initNodeAndText();
+
+    test("Construction", () => {
+      expect(text + "").toEqual("hello world");
+    });
+
+    describe("Mutation", () => {
+      test("insertion", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        text.insertAfter(5, " cruel");
+        expect(text + "").toEqual("hello cruel world");
+
+        text.insertAfter(0, "Hello, ");
+        expect(text + "").toEqual("Hello, hello cruel world");
+      });
+
+      test("deletion", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        text.deleteRange({ from: 3, to: 8 });
+        expect(text + "").toEqual("helrld");
+      });
+    });
+
+    describe("Position operations", () => {
+      test("idxBefore returns index before a position", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        // Get position at index 5 (between "hello" and " world")
+        const pos = text.posBefore(5);
+        expect(pos).toBeDefined();
+
+        // Verify idxBefore returns the index before the position (4)
+        // This makes sense as the position is between characters,
+        // and idxBefore returns the index of the last character before that position
+        const idx = text.idxBefore(pos!);
+        expect(idx).toBe(4); // Index of 'o' in "hello"
+      });
+
+      test("idxAfter returns index after a position", () => {
+        const text = CoPlainText.create("hello world", { owner: me });
+
+        // Get position at index 5 (between "hello" and " world")
+        const pos = text.posBefore(5);
+        expect(pos).toBeDefined();
+
+        // Verify idxAfter returns the index after the position (5)
+        // This makes sense as the position is between characters,
+        // and idxAfter returns the index of the first character after that position
+        const idx = text.idxAfter(pos!);
+        expect(idx).toBe(5); // Index of ' ' in "hello world"
+      });
+    });
+  });
+
+  describe("Loading and availability", () => {
+    test("can load text across peers", async () => {
+      const { me, text } = await initNodeAndText();
+      const id = text.id;
+
+      // Set up peer connections
+      const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+        peer1role: "server",
+        peer2role: "client",
+      });
+
+      if (!isControlledAccount(me)) {
+        throw "me is not a controlled account";
+      }
+      me._raw.core.node.syncManager.addPeer(secondPeer);
+      const { account: meOnSecondPeer } = await createJazzContext({
+        auth: fixedCredentialsAuth({
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        }),
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
+
+      // Load the text on the second peer
+      const loaded = await CoPlainText.load(id, meOnSecondPeer);
+      expect(loaded).toBeDefined();
+      expect(loaded!.toString()).toBe("hello world");
+    });
+  });
+
+  test("Subscription & auto-resolution", async () => {
+    const { me, text } = await initNodeAndText();
+
+    // Set up peer connections
+    const [initialAsPeer, secondPeer] = connectedPeers("initial", "second", {
+      peer1role: "server",
+      peer2role: "client",
+    });
+
+    if (!isControlledAccount(me)) {
+      throw "me is not a controlled account";
+    }
+    me._raw.core.node.syncManager.addPeer(secondPeer);
+    const { account: meOnSecondPeer } = await createJazzContext({
+      auth: fixedCredentialsAuth({
+        accountID: me.id,
+        secret: me._raw.agentSecret,
+      }),
+      sessionProvider: randomSessionProvider,
+      peersToLoadFrom: [initialAsPeer],
+      crypto: Crypto,
+    });
+
+    const queue = new cojsonInternals.Channel();
+
+    // Subscribe to text updates
+    CoPlainText.subscribe(text.id, meOnSecondPeer, (subscribedText) => {
+      void queue.push(subscribedText);
+    });
+
+    // Initial subscription should give us the text
+    const update1 = (await queue.next()).value;
+    expect(update1.toString()).toBe("hello world");
+
+    // When we make a change, we should get an update
+    text.insertAfter(5, " beautiful");
+    const update2 = (await queue.next()).value;
+    expect(update2.toString()).toBe("hello beautiful world");
+
+    // When we make another change, we should get another update
+    update2.deleteRange({ from: 5, to: 15 }); // Delete " beautiful"
+    const update3 = (await queue.next()).value;
+    expect(update3.toString()).toBe("hello world");
+  });
+});