jazz-tools 0.17.14 → 0.18.0

package/src/tools/tests/coFeed.test.ts

@@ -18,58 +18,48 @@ import {
 } from "../index.js";
 import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
+import { CoFeed, ControlledAccount, TypeSym } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
-let me = await Account.create({
-  creationProps: { name: "Hermes Puggington" },
-  crypto: Crypto,
-});
+let me: ControlledAccount;
 
 beforeEach(async () => {
   await setupJazzTestSync();
-
-  me = await createJazzTestAccount({
+  const account = await createJazzTestAccount({
     isCurrentActiveAccount: true,
     creationProps: { name: "Hermes Puggington" },
   });
+  if (!isControlledAccount(account)) {
+    throw new Error("account is not a controlled account");
+  }
+  me = account;
 });
 
 describe("Simple CoFeed operations", async () => {
-  const me = await Account.create({
-    creationProps: { name: "Hermes Puggington" },
-    crypto: Crypto,
-  });
-  if (!isControlledAccount(me)) {
-    throw "me is not a controlled account";
-  }
-  const TestStream = co.feed(z.string());
+  let TestStream: co.Feed<z.z.ZodString>;
+  let stream: CoFeed<string>;
 
-  const stream = TestStream.create(["milk"], { owner: me });
+  beforeEach(async () => {
+    TestStream = co.feed(z.string());
+    stream = TestStream.create(["milk"], { owner: me });
+  });
 
   test("Construction", () => {
-    expect(stream.perAccount[me.id]?.value).toEqual("milk");
-    expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
+    expect(stream.perAccount[me.$jazz.id]?.value).toEqual("milk");
+    expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual("milk");
   });
 
   describe("Create CoFeed with a reference", () => {
-    let me: Account;
-
-    beforeEach(async () => {
-      await setupJazzTestSync();
-      me = await createJazzTestAccount({
-        isCurrentActiveAccount: true,
-        creationProps: { name: "Hermes Puggington" },
-      });
-    });
-
     test("using a CoValue", () => {
       const Text = co.plainText();
       const TextStream = co.feed(Text);
 
-      const stream = TextStream.create([Text.create("milk")], { owner: me });
+      const stream = TextStream.create([Text.create("milk")], {
+        owner: me,
+      });
 
-      const coValue = stream.perAccount[me.id]?.value;
+      const coValue = stream.perAccount[me.$jazz.id]?.value;
       expect(coValue?.toString()).toEqual("milk");
     });
 
@@ -80,14 +70,14 @@ describe("Simple CoFeed operations", async () => {
 
         const stream = TextStream.create(["milk"], { owner: me });
 
-        const coValue = stream.perAccount[me.id]?.value;
+        const coValue = stream.perAccount[me.$jazz.id]?.value;
         expect(coValue?.toString()).toEqual("milk");
       });
 
       test("can create a coPlainText from an empty string", () => {
         const Schema = co.feed(co.plainText());
         const feed = Schema.create([""]);
-        expect(feed.perAccount[me.id]?.value?.toString()).toBe("");
+        expect(feed.perAccount[me.$jazz.id]?.value?.toString()).toBe("");
       });
     });
   });
@@ -96,34 +86,58 @@ describe("Simple CoFeed operations", async () => {
     const NullableTestStream = co.feed(z.string().nullable());
     const stream = NullableTestStream.create(["milk", null], { owner: me });
 
-    expect(stream.perAccount[me.id]?.value).toEqual(null);
-    expect(stream.perSession[me.sessionID]?.value).toEqual(null);
+    expect(stream.perAccount[me.$jazz.id]?.value).toEqual(null);
+    expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual(null);
   });
 
   test("Construction with an Account", () => {
     const stream = TestStream.create(["milk"], me);
 
-    expect(stream.perAccount[me.id]?.value).toEqual("milk");
-    expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
+    expect(stream.perAccount[me.$jazz.id]?.value).toEqual("milk");
+    expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual("milk");
   });
 
   test("Construction with a Group", () => {
     const group = Group.create(me);
     const stream = TestStream.create(["milk"], group);
 
-    expect(stream.perAccount[me.id]?.value).toEqual("milk");
-    expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
+    expect(stream.perAccount[me.$jazz.id]?.value).toEqual("milk");
+    expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual("milk");
   });
 
   describe("Mutation", () => {
-    test("pushing", () => {
-      stream.push("bread");
-      expect(stream.perAccount[me.id]?.value).toEqual("bread");
-      expect(stream.perSession[me.sessionID]?.value).toEqual("bread");
+    test("push element into CoFeed of non-collaborative values", () => {
+      stream.$jazz.push("bread");
+      expect(stream.perAccount[me.$jazz.id]?.value).toEqual("bread");
+      expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual("bread");
+
+      stream.$jazz.push("butter");
+      expect(stream.perAccount[me.$jazz.id]?.value).toEqual("butter");
+      expect(stream.perSession[me.$jazz.sessionID]?.value).toEqual("butter");
+    });
+
+    test("push CoValue into CoFeed of CoValues", () => {
+      const Schema = co.feed(co.plainText());
+      const stream = Schema.create(["milk"]);
+      stream.$jazz.push(Schema.element.create("bread"));
+      expect(stream.perAccount[me.$jazz.id]?.value?.toString()).toEqual(
+        "bread",
+      );
+      expect(stream.perSession[me.$jazz.sessionID]?.value?.toString()).toEqual(
+        "bread",
+      );
+    });
 
-      stream.push("butter");
-      expect(stream.perAccount[me.id]?.value).toEqual("butter");
-      expect(stream.perSession[me.sessionID]?.value).toEqual("butter");
+    test("push JSON into CoFeed of CoValues", () => {
+      const Schema = co.feed(co.plainText());
+      const stream = Schema.create(["milk"]);
+      stream.$jazz.push("bread");
+      expect(stream.perAccount[me.$jazz.id]?.value?.toString()).toEqual(
+        "bread",
+      );
+      expect(stream.perSession[me.$jazz.sessionID]?.value?.toString()).toEqual(
+        "bread",
+      );
     });
   });
 });
@@ -160,9 +174,8 @@ describe("CoFeed resolution", async () => {
     // expectTypeOf(stream[me.id]).not.toBeAny();
 
     expect(
-      stream.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      stream.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
+        ?.perAccount[me.$jazz.id]?.value,
     ).toEqual("milk");
   });
 
@@ -171,13 +184,13 @@ describe("CoFeed resolution", async () => {
 
     const anotherAccount = await createJazzTestAccount();
 
-    const loadedStream = await TestStream.load(stream.id, {
+    const loadedStream = await TestStream.load(stream.$jazz.id, {
       loadAs: anotherAccount,
     });
 
     assert(loadedStream);
 
-    const myStream = loadedStream.perAccount[me.id];
+    const myStream = loadedStream.perAccount[me.$jazz.id];
 
     assert(myStream);
 
@@ -185,7 +198,7 @@ describe("CoFeed resolution", async () => {
 
     assert(myStream.value);
 
-    const loadedNestedStreamByMe = myStream.value.perAccount[me.id];
+    const loadedNestedStreamByMe = myStream.value.perAccount[me.$jazz.id];
 
     assert(loadedNestedStreamByMe);
 
@@ -194,7 +207,7 @@ describe("CoFeed resolution", async () => {
     assert(loadedNestedStreamByMe.value);
 
     const loadedTwiceNestedStreamByMe =
-      loadedNestedStreamByMe.value.perAccount[me.id];
+      loadedNestedStreamByMe.value.perAccount[me.$jazz.id];
 
     assert(loadedTwiceNestedStreamByMe);
 
@@ -205,13 +218,14 @@ describe("CoFeed resolution", async () => {
 
   test("Subscription & auto-resolution", async () => {
     const { me, stream } = await initNodeAndStream();
+    const accountId = me.$jazz.id;
 
     const anotherAccount = await createJazzTestAccount();
 
     const queue = new Channel();
 
     TestStream.subscribe(
-      stream.id,
+      stream.$jazz.id,
       { loadAs: anotherAccount },
       (subscribedStream) => {
         void queue.push(subscribedStream);
@@ -220,36 +234,33 @@ describe("CoFeed resolution", async () => {
 
     const update1 = (await queue.next()).value;
     expect(
-      update1.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      update1.perAccount[accountId]?.value?.perAccount[accountId]?.value
+        ?.perAccount[accountId]?.value,
     ).toBe("milk");
 
     // When assigning a new nested stream, we get an update
     const newTwiceNested = TwiceNestedStream.create(["butter"], {
-      owner: stream._owner,
+      owner: stream.$jazz.owner,
     });
 
     const newNested = NestedStream.create([newTwiceNested], {
-      owner: stream._owner,
+      owner: stream.$jazz.owner,
     });
 
-    stream.push(newNested);
+    stream.$jazz.push(newNested);
 
     const update2 = (await queue.next()).value;
     expect(
-      update2.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      update2.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
+        ?.perAccount[me.$jazz.id]?.value,
     ).toBe("butter");
 
     // we get updates when the new nested stream changes
-    newTwiceNested.push("jam");
+    newTwiceNested.$jazz.push("jam");
     const update3 = (await queue.next()).value;
     expect(
-      update3.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      update3.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
+        ?.perAccount[me.$jazz.id]?.value,
     ).toBe("jam");
   });
 
@@ -258,24 +269,24 @@ describe("CoFeed resolution", async () => {
 
     const queue = new Channel();
 
-    TestStream.subscribe(stream.id, (subscribedStream) => {
+    TestStream.subscribe(stream.$jazz.id, (subscribedStream) => {
       void queue.push(subscribedStream);
     });
 
     const update1 = (await queue.next()).value;
     expect(
-      update1.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      update1.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
+        ?.perAccount[me.$jazz.id]?.value,
     ).toBe("milk");
 
-    stream.perAccount[me.id]!.value!.perAccount[me.id]!.value!.push("bread");
+    stream.perAccount[me.$jazz.id]!.value!.perAccount[
+      me.$jazz.id
+    ]!.value!.$jazz.push("bread");
 
     const update2 = (await queue.next()).value;
     expect(
-      update2.perAccount[me.id]?.value?.perAccount[me.id]?.value?.perAccount[
-        me.id
-      ]?.value,
+      update2.perAccount[me.$jazz.id]?.value?.perAccount[me.$jazz.id]?.value
+        ?.perAccount[me.$jazz.id]?.value,
     ).toBe("bread");
   });
 });
@@ -366,7 +377,7 @@ describe("FileStream loading & Subscription", async () => {
     const { stream } = await initNodeAndStream();
     const anotherAccount = await createJazzTestAccount();
 
-    const loadedStream = await FileStream.load(stream.id, {
+    const loadedStream = await FileStream.load(stream.$jazz.id, {
       loadAs: anotherAccount,
     });
 
@@ -388,7 +399,7 @@ describe("FileStream loading & Subscription", async () => {
     const queue = new Channel();
 
     FileStream.subscribe(
-      stream.id,
+      stream.$jazz.id,
       { loadAs: anotherAccount },
       (subscribedStream) => {
         void queue.push(subscribedStream);
@@ -451,7 +462,7 @@ describe("FileStream loading & Subscription", async () => {
 
     const queue = new Channel();
 
-    FileStream.subscribe(stream.id, (subscribedStream) => {
+    FileStream.subscribe(stream.$jazz.id, (subscribedStream) => {
       void queue.push(subscribedStream);
     });
 
@@ -503,7 +514,7 @@ describe("FileStream.load", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.load(stream.id, { loadAs: me });
+    const promise = FileStream.load(stream.$jazz.id, { loadAs: me });
 
     stream.push(new Uint8Array([2]));
     stream.end();
@@ -519,7 +530,7 @@ describe("FileStream.load", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.load(stream.id, {
+    const promise = FileStream.load(stream.$jazz.id, {
       loadAs: me,
       allowUnfinished: true,
     });
@@ -552,7 +563,7 @@ describe("FileStream.loadAsBlob", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.loadAsBlob(stream.id, { loadAs: me });
+    const promise = FileStream.loadAsBlob(stream.$jazz.id, { loadAs: me });
 
     stream.push(new Uint8Array([2]));
     stream.end();
@@ -568,7 +579,7 @@ describe("FileStream.loadAsBlob", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.loadAsBlob(stream.id, {
+    const promise = FileStream.loadAsBlob(stream.$jazz.id, {
       loadAs: me,
       allowUnfinished: true,
     });
@@ -602,7 +613,7 @@ describe("FileStream.loadAsBase64", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.loadAsBase64(stream.id, { loadAs: me });
+    const promise = FileStream.loadAsBase64(stream.$jazz.id, { loadAs: me });
 
     stream.push(new Uint8Array([2]));
     stream.end();
@@ -618,7 +629,7 @@ describe("FileStream.loadAsBase64", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.loadAsBase64(stream.id, {
+    const promise = FileStream.loadAsBase64(stream.$jazz.id, {
       loadAs: me,
       dataURL: true,
     });
@@ -637,7 +648,7 @@ describe("FileStream.loadAsBase64", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = FileStream.loadAsBase64(stream.id, {
+    const promise = FileStream.loadAsBase64(stream.$jazz.id, {
       loadAs: me,
       allowUnfinished: true,
     });
@@ -712,12 +723,12 @@ describe("FileStream large file loading", async () => {
     largeStream.end();
 
     // Wait for the large FileStream to be fully synced
-    await largeStream.waitForSync();
+    await largeStream.$jazz.waitForSync();
 
     const alice = await createJazzTestAccount();
 
     // Test loading the large FileStream
-    const loadedStream = await FileStream.load(largeStream.id, {
+    const loadedStream = await FileStream.load(largeStream.$jazz.id, {
       loadAs: alice,
       allowUnfinished: true,
     });
@@ -728,8 +739,8 @@ describe("FileStream large file loading", async () => {
     expect(loadedChunks).not.toBeNull();
     expect(loadedChunks?.finished).toBe(undefined);
 
-    expect(loadedStream._raw.core.knownState()).not.toEqual(
-      largeStream._raw.core.knownState(),
+    expect(loadedStream.$jazz.raw.core.knownState()).not.toEqual(
+      largeStream.$jazz.raw.core.knownState(),
     );
   });
 
@@ -759,12 +770,12 @@ describe("FileStream large file loading", async () => {
     largeStream.end();
 
     // Wait for the large FileStream to be fully synced
-    await largeStream.waitForSync();
+    await largeStream.$jazz.waitForSync();
 
     const alice = await createJazzTestAccount();
 
     // Test loading the large FileStream
-    const loadedStream = await FileStream.load(largeStream.id, {
+    const loadedStream = await FileStream.load(largeStream.$jazz.id, {
       loadAs: alice,
       allowUnfinished: false,
     });
@@ -776,8 +787,8 @@ describe("FileStream large file loading", async () => {
     expect(loadedChunks?.finished).toBe(true);
     expect(loadedChunks?.chunks).toHaveLength(numChunks); // 100 chunks of 1KB each
 
-    expect(loadedStream._raw.core.knownState()).toEqual(
-      largeStream._raw.core.knownState(),
+    expect(loadedStream.$jazz.raw.core.knownState()).toEqual(
+      largeStream.$jazz.raw.core.knownState(),
     );
   });
 });
@@ -790,12 +801,12 @@ describe("waitForSync", async () => {
 
     const stream = TestStream.create(["1", "2", "3"], { owner: clientAccount });
 
-    await stream.waitForSync({ timeout: 1000 });
+    await stream.$jazz.waitForSync({ timeout: 1000 });
 
     // Killing the client node so the serverNode can't load the map from it
     clientNode.gracefulShutdown();
 
-    const loadedStream = await serverNode.load(stream._raw.id);
+    const loadedStream = await serverNode.load(stream.$jazz.raw.id);
 
     expect(loadedStream).not.toBe("unavailable");
   });
@@ -809,12 +820,12 @@ describe("waitForSync", async () => {
     stream.push(new Uint8Array([2]));
     stream.end();
 
-    await stream.waitForSync({ timeout: 1000 });
+    await stream.$jazz.waitForSync({ timeout: 1000 });
 
     // Killing the client node so the serverNode can't load the map from it
     clientNode.gracefulShutdown();
 
-    const loadedStream = await serverNode.load(stream._raw.id);
+    const loadedStream = await serverNode.load(stream.$jazz.raw.id);
 
     expect(loadedStream).not.toBe("unavailable");
   });
@@ -825,8 +836,8 @@ describe("waitForSync", async () => {
     });
 
     const stream = FileStream.create();
-    expect(stream._owner._type).toEqual("Group");
-    expect(stream._owner.castAs(Group)._raw.roleOf(account._raw.id)).toEqual(
+    expect(stream.$jazz.owner[TypeSym]).toEqual("Group");
+    expect(stream.$jazz.owner.$jazz.raw.roleOf(account.$jazz.raw.id)).toEqual(
       "admin",
     );
   });

package/src/tools/tests/coList.test-d.ts

@@ -10,7 +10,7 @@ describe("CoList", () => {
 
       const list = StringList.create(["a", "b", "c"]);
 
-      type ExpectedType = string[];
+      type ExpectedType = ReadonlyArray<string>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -19,12 +19,12 @@ describe("CoList", () => {
       matches(list);
     });
 
-    test("has the _owner property", () => {
+    test("has the owner property", () => {
       const StringList = co.list(z.string());
 
       const list = StringList.create(["a", "b", "c"], Account.getMe());
 
-      expectTypeOf(list._owner).toEqualTypeOf<Account | Group>();
+      expectTypeOf(list.$jazz.owner).toEqualTypeOf<Group>();
     });
 
     test("CoList with reference", () => {
@@ -42,7 +42,7 @@ describe("CoList", () => {
         undefined,
       ]);
 
-      type ExpectedType = Loaded<typeof Dog>[];
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog>>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -64,7 +64,7 @@ describe("CoList", () => {
         undefined,
       ]);
 
-      type ExpectedType = (Loaded<typeof Dog> | undefined)[];
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog> | undefined>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -93,7 +93,7 @@ describe("CoList", () => {
 
       const list = DogList.create([dog, undefined]);
 
-      type ExpectedType = (Loaded<typeof Dog> | undefined)[];
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog> | undefined>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -121,7 +121,7 @@ describe("CoList", () => {
 
       const list = DogList.create([rex]);
 
-      type ExpectedType = Loaded<typeof Dog>[];
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog>>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -138,7 +138,7 @@ describe("CoList", () => {
         co.list(z.string()).create(["c", "d"]),
       ]);
 
-      type ExpectedType = string[][];
+      type ExpectedType = ReadonlyArray<ReadonlyArray<string>>;
 
       function matches(value: ExpectedType) {
         return value;
@@ -152,7 +152,7 @@ describe("CoList", () => {
 
       const list = EnumList.create(["a", "b", "c"]);
 
-      type ExpectedType = ("a" | "b" | "c")[];
+      type ExpectedType = ReadonlyArray<"a" | "b" | "c">;
 
       function matches(value: ExpectedType) {
         return value;
@@ -176,13 +176,13 @@ describe("CoList", () => {
         Dog.create({ name: "Fido", breed: "Poodle" }),
       ]);
 
-      const loadedList = await DogList.load(list.id, {
+      const loadedList = await DogList.load(list.$jazz.id, {
         resolve: {
           $each: true,
         },
       });
 
-      type ExpectedType = Loaded<typeof Dog>[] | null;
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog>> | null;
 
       function matches(value: ExpectedType) {
         return value;
@@ -209,20 +209,13 @@ describe("CoList", () => {
         Dog.create({ name: "Fido", breed: "Poodle" }),
       ]);
 
-      const loadedList = await DogList.load(list.id, {
+      const loadedList = await DogList.load(list.$jazz.id, {
         resolve: {
           $each: { $onError: null },
         },
       });
 
-      type ExpectedType =
-        | (
-            | (Loaded<typeof Dog> & {
-                $onError: never;
-              })
-            | null
-          )[]
-        | null;
+      type ExpectedType = ReadonlyArray<Loaded<typeof Dog> | null> | null;
 
       function matches(value: ExpectedType) {
         return value;
@@ -247,7 +240,7 @@ describe("CoList", () => {
         ]),
       ]);
 
-      const loadedList = await NestedList.load(list.id, {
+      const loadedList = await NestedList.load(list.$jazz.id, {
         resolve: {
           $each: {
             $each: true,
@@ -255,7 +248,9 @@ describe("CoList", () => {
         },
       });
 
-      type ExpectedType = Loaded<typeof Dog>[][] | null;
+      type ExpectedType = ReadonlyArray<
+        ReadonlyArray<Loaded<typeof Dog>>
+      > | null;
 
       function matches(value: ExpectedType) {
         return value;
@@ -292,7 +287,7 @@ describe("CoList", () => {
         ],
       });
 
-      const loadedPerson = await Person.load(person.id, {
+      const loadedPerson = await Person.load(person.$jazz.id, {
         resolve: { dogs: { $onError: null } },
       });