jazz-tools 0.9.23 → 0.10.1

package/src/tests/coFeed.test.ts

@@ -1,4 +1,4 @@
-import { connectedPeers } from "cojson/src/streamUtils.ts";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, test } from "vitest";
 import {
   Account,
@@ -6,19 +6,21 @@ import {
   FileStream,
   Group,
   ID,
-  WasmCrypto,
   co,
   cojsonInternals,
-  createJazzContext,
-  fixedCredentialsAuth,
   isControlledAccount,
-} from "../index.web.js";
-import { randomSessionProvider } from "../internal.js";
+} from "../index.js";
+import {
+  createJazzContextFromExistingCredentials,
+  randomSessionProvider,
+} from "../internal.js";
 import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
 
+const connectedPeers = cojsonInternals.connectedPeers;
+
 describe("Simple CoFeed operations", async () => {
   const me = await Account.create({
     creationProps: { name: "Hermes Puggington" },
@@ -111,15 +113,16 @@ describe("CoFeed resolution", async () => {
       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 { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const loadedStream = await TestStream.load(stream.id, meOnSecondPeer, []);
 
@@ -196,15 +199,16 @@ describe("CoFeed resolution", async () => {
     if (!isControlledAccount(me)) {
       throw "me is not a controlled account";
     }
-    const { account: meOnSecondPeer } = await createJazzContext({
-      auth: fixedCredentialsAuth({
-        accountID: me.id,
-        secret: me._raw.agentSecret,
-      }),
-      sessionProvider: randomSessionProvider,
-      peersToLoadFrom: [initialAsPeer],
-      crypto: Crypto,
-    });
+    const { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const queue = new cojsonInternals.Channel();
 
@@ -315,15 +319,16 @@ describe("FileStream loading & Subscription", async () => {
       throw "me is not a controlled account";
     }
     me._raw.core.node.syncManager.addPeer(secondAsPeer);
-    const { account: meOnSecondPeer } = await createJazzContext({
-      auth: fixedCredentialsAuth({
-        accountID: me.id,
-        secret: me._raw.agentSecret,
-      }),
-      sessionProvider: randomSessionProvider,
-      peersToLoadFrom: [initialAsPeer],
-      crypto: Crypto,
-    });
+    const { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const loadedStream = await FileStream.load(stream.id, meOnSecondPeer, []);
 
@@ -346,15 +351,16 @@ describe("FileStream loading & Subscription", async () => {
     if (!isControlledAccount(me)) {
       throw "me is not a controlled account";
     }
-    const { account: meOnSecondPeer } = await createJazzContext({
-      auth: fixedCredentialsAuth({
-        accountID: me.id,
-        secret: me._raw.agentSecret,
-      }),
-      sessionProvider: randomSessionProvider,
-      peersToLoadFrom: [initialAsPeer],
-      crypto: Crypto,
-    });
+    const { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const queue = new cojsonInternals.Channel();
 

package/src/tests/coList.test.ts

@@ -1,18 +1,18 @@
-import { connectedPeers } from "cojson/src/streamUtils.ts";
+import { cojsonInternals } from "cojson";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, test } from "vitest";
 import {
   Account,
   CoList,
   Group,
-  WasmCrypto,
   co,
-  cojsonInternals,
-  createJazzContext,
-  fixedCredentialsAuth,
+  createJazzContextFromExistingCredentials,
   isControlledAccount,
-} from "../index.web.js";
+} from "../index.js";
 import { randomSessionProvider } from "../internal.js";
 
+const connectedPeers = cojsonInternals.connectedPeers;
+
 const Crypto = await WasmCrypto.create();
 
 describe("Simple CoList operations", async () => {
@@ -170,15 +170,16 @@ describe("CoList resolution", async () => {
       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 { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const loadedList = await TestList.load(list.id, meOnSecondPeer, []);
 
@@ -241,15 +242,16 @@ describe("CoList resolution", async () => {
       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 { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const queue = new cojsonInternals.Channel();
 

package/src/tests/coMap.test.ts

@@ -1,19 +1,19 @@
-import { connectedPeers } from "cojson/src/streamUtils.ts";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, expectTypeOf, test } from "vitest";
 import { Group, randomSessionProvider } from "../exports.js";
 import {
   Account,
   CoMap,
   Encoders,
-  WasmCrypto,
   co,
   cojsonInternals,
-  createJazzContext,
-  fixedCredentialsAuth,
+  createJazzContextFromExistingCredentials,
   isControlledAccount,
-} from "../index.web.js";
+} from "../index.js";
 import { setupTwoNodes } from "./utils.js";
 
+const connectedPeers = cojsonInternals.connectedPeers;
+
 const Crypto = await WasmCrypto.create();
 
 class TestMap extends CoMap {
@@ -408,15 +408,16 @@ describe("CoMap resolution", async () => {
       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 { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const loadedMap = await TestMap.load(map.id, meOnSecondPeer, {});
 
@@ -479,15 +480,16 @@ describe("CoMap resolution", async () => {
       throw "me is not a controlled account";
     }
     me._raw.core.node.syncManager.addPeer(secondAsPeer);
-    const { account: meOnSecondPeer } = await createJazzContext({
-      auth: fixedCredentialsAuth({
-        accountID: me.id,
-        secret: me._raw.agentSecret,
-      }),
-      sessionProvider: randomSessionProvider,
-      peersToLoadFrom: [initialAsPeer],
-      crypto: Crypto,
-    });
+    const { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const queue = new cojsonInternals.Channel<TestMap>();
 

package/src/tests/coPlainText.test.ts

@@ -1,18 +1,18 @@
-import { connectedPeers } from "cojson/src/streamUtils.js";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, test } from "vitest";
 import {
   Account,
   CoPlainText,
-  WasmCrypto,
   cojsonInternals,
-  createJazzContext,
-  fixedCredentialsAuth,
+  createJazzContextFromExistingCredentials,
   isControlledAccount,
-} from "../index.web.js";
+} from "../index.js";
 import { randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
+const connectedPeers = cojsonInternals.connectedPeers;
+
 describe("CoPlainText", () => {
   const initNodeAndText = async () => {
     const me = await Account.create({
@@ -97,15 +97,16 @@ describe("CoPlainText", () => {
         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 { account: meOnSecondPeer } =
+        await createJazzContextFromExistingCredentials({
+          credentials: {
+            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);
@@ -127,15 +128,16 @@ describe("CoPlainText", () => {
       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 { account: meOnSecondPeer } =
+      await createJazzContextFromExistingCredentials({
+        credentials: {
+          accountID: me.id,
+          secret: me._raw.agentSecret,
+        },
+        sessionProvider: randomSessionProvider,
+        peersToLoadFrom: [initialAsPeer],
+        crypto: Crypto,
+      });
 
     const queue = new cojsonInternals.Channel();
 

package/src/tests/coRichText.test.ts

@@ -1,4 +1,4 @@
-import { connectedPeers } from "cojson/src/streamUtils.ts";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { describe, expect, test } from "vitest";
 import { splitNode } from "../coValues/coRichText.js";
 import {
@@ -7,14 +7,13 @@ import {
   Marks,
   type TextPos,
   type TreeNode,
-  WasmCrypto,
   cojsonInternals,
-  createJazzContext,
-  fixedCredentialsAuth,
+  createJazzContextFromExistingCredentials,
   isControlledAccount,
-} from "../index.web.js";
+} from "../index.js";
 import { randomSessionProvider } from "../internal.js";
 
+const connectedPeers = cojsonInternals.connectedPeers;
 const Crypto = await WasmCrypto.create();
 
 describe("CoRichText", async () => {
@@ -592,15 +591,16 @@ describe("CoRichText", async () => {
         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 { account: meOnSecondPeer } =
+        await createJazzContextFromExistingCredentials({
+          credentials: {
+            accountID: me.id,
+            secret: me._raw.agentSecret,
+          },
+          sessionProvider: randomSessionProvider,
+          peersToLoadFrom: [initialAsPeer],
+          crypto: Crypto,
+        });
 
       const loadedText = await CoRichText.load(text.id, meOnSecondPeer, {
         marks: [{}],
@@ -631,15 +631,16 @@ describe("CoRichText", async () => {
         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 { account: meOnSecondPeer } =
+        await createJazzContextFromExistingCredentials({
+          credentials: {
+            accountID: me.id,
+            secret: me._raw.agentSecret,
+          },
+          sessionProvider: randomSessionProvider,
+          peersToLoadFrom: [initialAsPeer],
+          crypto: Crypto,
+        });
 
       const queue = new cojsonInternals.Channel<CoRichText>();