jazz-tools 0.8.3 → 0.8.11

package/src/tests/subscribe.test.ts

@@ -0,0 +1,348 @@
+const Crypto = await WasmCrypto.create();
+import { expect, describe, it, vi, onTestFinished } from "vitest";
+import { connectedPeers } from "cojson/src/streamUtils.js";
+import {
+    Account,
+    CoList,
+    CoMap,
+    CoStream,
+    WasmCrypto,
+    co,
+    isControlledAccount,
+    createJazzContext,
+    fixedCredentialsAuth,
+} from "../index.web.js";
+import {
+    BinaryCoStream,
+    Group,
+    randomSessionProvider,
+    subscribeToCoValue,
+} from "../internal.js";
+
+class ChatRoom extends CoMap {
+    messages = co.ref(MessagesList);
+    name = co.string;
+}
+
+class Message extends CoMap {
+    text = co.string;
+    reactions = co.ref(ReactionsStream);
+    attachment = co.optional.ref(BinaryCoStream);
+}
+
+class MessagesList extends CoList.Of(co.ref(Message)) {}
+class ReactionsStream extends CoStream.Of(co.string) {}
+
+async function setupAccount() {
+    const me = await Account.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
+
+    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,
+    });
+
+    return { me, meOnSecondPeer };
+}
+
+function createChatRoom(me: Account | Group, name: string) {
+    return ChatRoom.create(
+        { messages: MessagesList.create([], { owner: me }), name },
+        { owner: me },
+    );
+}
+
+function createMessage(me: Account | Group, text: string) {
+    return Message.create(
+        { text, reactions: ReactionsStream.create([], { owner: me }) },
+        { owner: me },
+    );
+}
+
+describe("subscribeToCoValue", () => {
+    it("subscribes to a CoMap", async () => {
+        const { me, meOnSecondPeer } = await setupAccount();
+
+        const chatRoom = createChatRoom(me, "General");
+        const updateFn = vi.fn();
+
+        const unsubscribe = subscribeToCoValue(
+            ChatRoom,
+            chatRoom.id,
+            meOnSecondPeer,
+            {},
+            updateFn,
+        );
+
+        onTestFinished(unsubscribe);
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+
+        expect(updateFn).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: chatRoom.id,
+                messages: null,
+                name: "General",
+            }),
+        );
+
+        updateFn.mockClear();
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+
+        expect(updateFn).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: chatRoom.id,
+                name: "General",
+                messages: expect.any(Array),
+            }),
+        );
+
+        updateFn.mockClear();
+        chatRoom.name = "Lounge";
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+
+        expect(updateFn).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: chatRoom.id,
+                name: "Lounge",
+                messages: expect.any(Array),
+            }),
+        );
+    });
+
+    it("shouldn't fire updates until the declared load depth isn't reached", async () => {
+        const { me, meOnSecondPeer } = await setupAccount();
+
+        const chatRoom = createChatRoom(me, "General");
+        const updateFn = vi.fn();
+
+        const unsubscribe = subscribeToCoValue(
+            ChatRoom,
+            chatRoom.id,
+            meOnSecondPeer,
+            {
+                messages: [],
+            },
+            updateFn,
+        );
+
+        onTestFinished(unsubscribe);
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+
+        expect(updateFn).toHaveBeenCalledTimes(1);
+        expect(updateFn).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: chatRoom.id,
+                name: "General",
+                messages: expect.any(Array),
+            }),
+        );
+    });
+
+    it("should fire updates when a ref entity is updates", async () => {
+        const { me, meOnSecondPeer } = await setupAccount();
+
+        const chatRoom = createChatRoom(me, "General");
+        const message = createMessage(me, "Hello Luigi, are you ready to save the princess?");
+        chatRoom.messages?.push(message);
+
+        const updateFn = vi.fn()
+
+        const unsubscribe = subscribeToCoValue(
+            ChatRoom,
+            chatRoom.id,
+            meOnSecondPeer,
+            {
+                messages: [{
+                }],
+            },
+            updateFn,
+        );
+
+        onTestFinished(unsubscribe);
+
+        await waitFor(() => {
+            const lastValue = updateFn.mock.lastCall[0];
+
+            expect(lastValue?.messages?.[0]?.text).toBe(message.text);
+        });
+
+        message.text = "Nevermind, she was gone to the supermarket";
+        updateFn.mockClear();
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+        
+        const lastValue = updateFn.mock.lastCall[0];
+        expect(lastValue?.messages?.[0]?.text).toBe("Nevermind, she was gone to the supermarket");
+    });
+
+    it("should handle the updates as immutable changes", async () => {
+        const { me, meOnSecondPeer } = await setupAccount();
+
+        const chatRoom = createChatRoom(me, "General");
+        const message = createMessage(me, "Hello Luigi, are you ready to save the princess?");
+        const message2 = createMessage(me, "Let's go!");
+        chatRoom.messages?.push(message);
+        chatRoom.messages?.push(message2);
+
+        const updateFn = vi.fn()
+
+        const unsubscribe = subscribeToCoValue(
+            ChatRoom,
+            chatRoom.id,
+            meOnSecondPeer,
+            {
+                messages: [{
+                    reactions: [],
+                }],
+            },
+            updateFn,
+        );
+
+        onTestFinished(unsubscribe);
+
+        await waitFor(() => {
+            const lastValue = updateFn.mock.lastCall[0];
+
+            expect(lastValue?.messages?.[0]?.text).toBe(message.text);
+        });
+
+        const initialValue = updateFn.mock.lastCall[0];
+        const initialMessagesList = initialValue?.messages;
+        const initialMessage1 = initialValue?.messages[0];
+        const initialMessage2 = initialValue?.messages[1];
+        const initialMessageReactions = initialValue?.messages[0].reactions;
+
+        message.reactions?.push("👍");
+
+        updateFn.mockClear();
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+        
+        const lastValue = updateFn.mock.lastCall[0];
+        expect(lastValue).not.toBe(initialValue);
+        expect(lastValue.messages).not.toBe(initialMessagesList);
+        expect(lastValue.messages[0]).not.toBe(initialMessage1);
+        expect(lastValue.messages[0].reactions).not.toBe(initialMessageReactions);
+
+        // This shouldn't change
+        expect(lastValue.messages[1]).toBe(initialMessage2);
+
+        // TODO: The initial should point at that snapshot in time
+        // expect(lastValue.messages).not.toBe(initialValue.messages);
+        // expect(lastValue.messages[0]).not.toBe(initialValue.messages[0]);
+        // expect(lastValue.messages[1]).toBe(initialValue.messages[1]);
+        // expect(lastValue.messages[0].reactions).not.toBe(initialValue.messages[0].reactions);
+    });
+
+    it("should keep the same identity on the ref entities when a property is updated", async () => {
+        const { me, meOnSecondPeer } = await setupAccount();
+
+        const chatRoom = createChatRoom(me, "General");
+        const message = createMessage(me, "Hello Luigi, are you ready to save the princess?");
+        const message2 = createMessage(me, "Let's go!");
+        chatRoom.messages?.push(message);
+        chatRoom.messages?.push(message2);
+
+        const updateFn = vi.fn()
+
+        const unsubscribe = subscribeToCoValue(
+            ChatRoom,
+            chatRoom.id,
+            meOnSecondPeer,
+            {
+                messages: [{
+                    reactions: [],
+                }],
+            },
+            updateFn,
+        );
+
+        onTestFinished(unsubscribe);
+
+        await waitFor(() => {
+            const lastValue = updateFn.mock.lastCall[0];
+
+            expect(lastValue?.messages?.[0]?.text).toBe(message.text);
+            expect(lastValue?.messages?.[1]?.text).toBe(message2.text);
+        });
+
+        const initialValue = updateFn.mock.lastCall[0];
+        chatRoom.name = "Me and Luigi";
+
+        updateFn.mockClear();
+
+        await waitFor(() => {
+            expect(updateFn).toHaveBeenCalled();
+        });
+        
+        const lastValue = updateFn.mock.lastCall[0];
+        expect(lastValue).not.toBe(initialValue);
+        expect(lastValue.name).toBe("Me and Luigi");
+        expect(initialValue.name).toBe("General");
+        
+        expect(lastValue.messages).toBe(initialValue.messages);
+        expect(lastValue.messages[0]).toBe(initialValue.messages[0]);
+        expect(lastValue.messages[1]).toBe(initialValue.messages[1]);
+    });
+});
+
+
+function waitFor(callback: () => boolean | void) {
+    return new Promise<void>((resolve, reject) => {
+        const checkPassed = () => {
+            try {
+                return { ok: callback(), error: null };
+            } catch (error) {
+                return { ok: false, error };
+            }
+        };
+
+        let retries = 0;
+
+        const interval = setInterval(() => {
+            const { ok, error } = checkPassed();
+
+            if (ok !== false) {
+                clearInterval(interval);
+                resolve();
+            }
+
+            if (++retries > 10) {
+                clearInterval(interval);
+                reject(error);
+            }
+        }, 100);
+    });
+}

package/.turbo/turbo-build.log

@@ -1,8 +0,0 @@
-
-> jazz-tools@0.8.1 build /Users/anselm/jazz/jazz/packages/jazz-tools
-> npm run lint && rm -rf ./dist && tsc --sourceMap --outDir dist
-
-
-> jazz-tools@0.8.1 lint
-> eslint . --ext ts,tsx
-

package/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> jazz-tools@0.7.35-guest-auth.5 lint /Users/anselm/jazz/jazz/packages/jazz-tools
-> eslint . --ext ts,tsx
-

package/.turbo/turbo-test.log

@@ -1,144 +0,0 @@
-
-> jazz-tools@0.7.35-unique.2 test /Users/anselm/jazz/jazz/packages/jazz-tools
-> vitest --run
-
-
- RUN  v0.34.6 /Users/anselm/jazz/jazz/packages/jazz-tools
-
- ✓ src/tests/groupsAndAccounts.test.ts  (1 test) 64ms
-stdout | unknown test
-TestMap schema undefined
-
- ✓ src/tests/deepLoading.test.ts  (3 tests) 83ms
-stdout | src/tests/coList.test.ts > Simple CoList operations > Mutation > splice
-[ 'bread', 'onion' ] 0
-[ 'bread', 'salt', 'onion' ] 1
-
-stdout | src/tests/coList.test.ts > CoList resolution > Subscription & auto-resolution
-subscribedList?.[0]?.[0]?.[0] undefined
-subscribedList?.[0]?.[0]?.[0] undefined
-subscribedList?.[0]?.[0]?.[0] a
-subscribedList?.[0]?.[0]?.[0] x
-subscribedList?.[0]?.[0]?.[0] y
-subscribedList?.[0]?.[0]?.[0] w
-
- ✓ src/tests/coList.test.ts  (10 tests) 190ms
-stdout | src/tests/coStream.test.ts > CoStream resolution > Subscription & auto-resolution
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.414Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value undefined
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value undefined
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.414Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value null
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value undefined
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.414Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value {
-  id: 'co_zHELVqRmAN6YuGDpKqVrSXJ5qe1',
-  _type: 'CoStream',
-  perSession: undefined,
-  co_zURWEpvoH1e35FGHVxadgXKU8Ri: 'milk',
-  in: { co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF: 'milk' }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value milk
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.414Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value {
-  id: 'co_zHELVqRmAN6YuGDpKqVrSXJ5qe1',
-  _type: 'CoStream',
-  perSession: undefined,
-  co_zURWEpvoH1e35FGHVxadgXKU8Ri: 'bread',
-  in: {
-    co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_ziAMdGVstAxF: 'milk',
-    co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_zgik2JjD86Qa: 'bread'
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value bread
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.424Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_zgik2JjD86Qa',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value {
-  id: 'co_zJmdvJY15XJkWF3n3rwPgGfebxa',
-  _type: 'CoStream',
-  perSession: undefined,
-  co_zURWEpvoH1e35FGHVxadgXKU8Ri: 'butter',
-  in: { co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_zgik2JjD86Qa: 'butter' }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value butter
-subscribedStream[me.id] {
-  value: [Getter],
-  ref: [Getter],
-  by: [Getter],
-  madeAt: 2024-09-05T17:35:38.424Z,
-  tx: {
-    sessionID: 'co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_zgik2JjD86Qa',
-    txIndex: 0
-  }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value {
-  id: 'co_zJmdvJY15XJkWF3n3rwPgGfebxa',
-  _type: 'CoStream',
-  perSession: undefined,
-  co_zURWEpvoH1e35FGHVxadgXKU8Ri: 'jam',
-  in: { co_zURWEpvoH1e35FGHVxadgXKU8Ri_session_zgik2JjD86Qa: 'jam' }
-}
-subscribedStream[me.id]?.value?.[me.id]?.value?.[me.id]?.value jam
-
- ✓ src/tests/coStream.test.ts  (10 tests) 205ms
-stdout | src/tests/coMap.test.ts > CoMap resolution > Subscription & auto-resolution
-subscribedMap.nested?.twiceNested?.taste undefined
-subscribedMap.nested?.twiceNested?.taste undefined
-subscribedMap.nested?.twiceNested?.taste sour
-subscribedMap.nested?.twiceNested?.taste sour
-subscribedMap.nested?.twiceNested?.taste sweet
-subscribedMap.nested?.twiceNested?.taste sweet
-subscribedMap.nested?.twiceNested?.taste salty
-subscribedMap.nested?.twiceNested?.taste umami
-
- ✓ src/tests/coMap.test.ts  (20 tests) 257ms
-
- Test Files  5 passed (5)
-      Tests  44 passed (44)
-   Start at  18:35:37
-   Duration  929ms (transform 419ms, setup 0ms, collect 2.29s, tests 799ms, environment 0ms, prepare 298ms)
-