jazz-tools 0.7.35-unique.2 → 0.8.0

package/src/implementation/subscriptionScope.ts

@@ -5,6 +5,7 @@ import type {
     ID,
     CoValueClass,
     CoValueFromRaw,
+    AnonymousJazzAgent,
 } from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
@@ -17,7 +18,7 @@ const TRACE_INVALIDATIONS = false;
 
 export class SubscriptionScope<Root extends CoValue> {
     scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
-    subscriber: Account;
+    subscriber: Account | AnonymousJazzAgent;
     entries = new Map<
         ID<CoValue>,
         | { state: "loading"; immediatelyUnsub?: boolean }
@@ -89,32 +90,34 @@ export class SubscriptionScope<Root extends CoValue> {
                 immediatelyUnsub: false,
             } as const;
             this.entries.set(accessedOrSetId, loadingEntry);
-            void this.subscriber._raw.core.node
-                .loadCoValueCore(accessedOrSetId)
-                .then((core) => {
-                    if (
-                        loadingEntry.state === "loading" &&
-                        loadingEntry.immediatelyUnsub
-                    ) {
-                        return;
-                    }
-                    if (core !== "unavailable") {
-                        const entry = {
-                            state: "loaded" as const,
-                            rawUnsub: () => {}, // placeholder
-                        };
-                        this.entries.set(accessedOrSetId, entry);
+            const node =
+                this.subscriber._type === "Account"
+                    ? this.subscriber._raw.core.node
+                    : this.subscriber.node;
+            void node.loadCoValueCore(accessedOrSetId).then((core) => {
+                if (
+                    loadingEntry.state === "loading" &&
+                    loadingEntry.immediatelyUnsub
+                ) {
+                    return;
+                }
+                if (core !== "unavailable") {
+                    const entry = {
+                        state: "loaded" as const,
+                        rawUnsub: () => {}, // placeholder
+                    };
+                    this.entries.set(accessedOrSetId, entry);
 
-                        const rawUnsub = core.subscribe((rawUpdate) => {
-                            // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
-                            if (!rawUpdate) return;
-                            this.invalidate(accessedOrSetId);
-                            this.scheduleUpdate();
-                        });
+                    const rawUnsub = core.subscribe((rawUpdate) => {
+                        // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
+                        if (!rawUpdate) return;
+                        this.invalidate(accessedOrSetId);
+                        this.scheduleUpdate();
+                    });
 
-                        entry.rawUnsub = rawUnsub;
-                    }
-                });
+                    entry.rawUnsub = rawUnsub;
+                }
+            });
         }
     }
 

package/src/index.ts

@@ -34,4 +34,7 @@ export {
     type AuthResult,
     createJazzContext,
     fixedCredentialsAuth,
+    ephemeralCredentialsAuth,
+    AnonymousJazzAgent,
+    createAnonymousJazzContext,
 } from "./internal.js";

package/src/tests/coMap.test.ts

@@ -1,4 +1,4 @@
-import { expect, describe, test } from "vitest";
+import { expect, describe, test, expectTypeOf } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import {
     Account,
@@ -592,6 +592,7 @@ describe("CoMap applyDiff", async () => {
         birthday = co.encoded(Encoders.Date);
         nested = co.ref(NestedMap);
         optionalField = co.optional.string;
+        optionalNested = co.optional.ref(NestedMap);
     }
 
     class NestedMap extends CoMap {
@@ -737,6 +738,143 @@ describe("CoMap applyDiff", async () => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         expect((map as any).invalidField).toBeUndefined();
     });
+
+    test("applyDiff with optional reference set to null", () => {
+        const map = TestMap.create(
+            {
+                name: "Jack",
+                age: 50,
+                isActive: true,
+                birthday: new Date("1970-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+                optionalNested: NestedMap.create(
+                    { value: "optional" },
+                    { owner: me },
+                ),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            optionalNested: null,
+        };
+
+        map.applyDiff(newValues);
+
+        expect(map.optionalNested).toBeNull();
+    });
+
+    test("applyDiff with required reference set to null should throw", () => {
+        const map = TestMap.create(
+            {
+                name: "Kate",
+                age: 55,
+                isActive: true,
+                birthday: new Date("1965-01-01"),
+                nested: NestedMap.create({ value: "original" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        const newValues = {
+            nested: null,
+        };
+
+        // @ts-expect-error testing invalid usage
+        expect(() => map.applyDiff(newValues)).toThrowError(
+            "Cannot set required reference nested to null",
+        );
+    });
+});
+
+describe("CoMap Typescript validation", async () => {
+    const me = await Account.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
+
+    test("Is not ok to pass null into a required ref", () => {
+        class TestMap extends CoMap {
+            required = co.ref(NestedMap);
+            optional = co.optional.ref(NestedMap);
+        }
+
+        class NestedMap extends CoMap {
+            value = co.string;
+        }
+
+        expectTypeOf<typeof TestMap.create<TestMap>>().toBeCallableWith(
+            {
+                optional: NestedMap.create({ value: "" }, { owner: me }),
+                // @ts-expect-error null can't be passed to a non-optional field
+                required: null,
+            },
+            { owner: me },
+        );
+    });
+
+    test("Is not ok if a required ref is omitted", () => {
+        class TestMap extends CoMap {
+            required = co.ref(NestedMap);
+            optional = co.ref(NestedMap, { optional: true });
+        }
+
+        class NestedMap extends CoMap {
+            value = co.string;
+        }
+
+        expectTypeOf<typeof TestMap.create<TestMap>>().toBeCallableWith(
+            // @ts-expect-error non-optional fields can't be omitted
+            {},
+            { owner: me },
+        );
+    });
+
+    test("Is ok to omit optional fields", () => {
+        class TestMap extends CoMap {
+            required = co.ref(NestedMap);
+            optional = co.ref(NestedMap, { optional: true });
+        }
+
+        class NestedMap extends CoMap {
+            value = co.string;
+        }
+
+        expectTypeOf<typeof TestMap.create<TestMap>>().toBeCallableWith(
+            {
+                required: NestedMap.create({ value: "" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        expectTypeOf<typeof TestMap.create<TestMap>>().toBeCallableWith(
+            {
+                required: NestedMap.create({ value: "" }, { owner: me }),
+                optional: null,
+            },
+            { owner: me },
+        );
+    });
+
+    test("the required refs should be nullable", () => {
+        class TestMap extends CoMap {
+            required = co.ref(NestedMap);
+            optional = co.ref(NestedMap, { optional: true });
+        }
+
+        class NestedMap extends CoMap {
+            value = co.string;
+        }
+
+        const map = TestMap.create(
+            {
+                required: NestedMap.create({ value: "" }, { owner: me }),
+            },
+            { owner: me },
+        );
+
+        expectTypeOf(map.required).toBeNullable();
+    });
 });
 
 describe("Creating and finding unique CoMaps", async () => {

package/src/tests/coStream.test.ts

@@ -443,3 +443,56 @@ describe("BinaryCoStream loading & Subscription", async () => {
         });
     });
 });
+
+describe("BinaryCoStream.loadAsBlob", async () => {
+    async function setup() {
+        const me = await Account.create({
+            creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
+        });
+
+        const stream = BinaryCoStream.create({ owner: me });
+
+        stream.start({ mimeType: "text/plain" });
+
+        return { stream, me };
+    }
+
+    test("resolves only when the stream is ended", async () => {
+        const { stream, me } = await setup();
+        stream.push(new Uint8Array([1]));
+
+        const promise = BinaryCoStream.loadAsBlob(stream.id, me);
+
+        await stream.ensureLoaded([]);
+
+        stream.push(new Uint8Array([2]));
+        stream.end();
+
+        const blob = await promise;
+
+        // The promise resolves only when the stream is ended
+        // so we get a blob with all the chunks
+        expect(blob?.size).toBe(2);
+    });
+
+    test("resolves with an unfinshed blob if allowUnfinished: true", async () => {
+        const { stream, me } = await setup();
+        stream.push(new Uint8Array([1]));
+
+        const promise = BinaryCoStream.loadAsBlob(stream.id, me, {
+            allowUnfinished: true,
+        });
+
+        await stream.ensureLoaded([]);
+
+        stream.push(new Uint8Array([2]));
+        stream.end();
+
+        const blob = await promise;
+
+        // The promise resolves before the stream is ended
+        // so we get a blob only with the first chunk
+        expect(blob?.size).toBe(1);
+    });
+});

package/src/tests/deepLoading.test.ts

@@ -60,6 +60,7 @@ describe("Deep loading with depth arg", async () => {
     });
 
     test("loading a deeply nested object will wait until all required refs are loaded", async () => {
+        const ownership = { owner: me };
         const map = TestMap.create(
             {
                 list: TestList.create(
@@ -70,19 +71,19 @@ describe("Deep loading with depth arg", async () => {
                                     [
                                         InnermostMap.create(
                                             { value: "hello" },
-                                            { owner: me },
+                                            ownership,
                                         ),
                                     ],
-                                    { owner: me },
+                                    ownership,
                                 ),
                             },
-                            { owner: me },
+                            ownership,
                         ),
                     ],
-                    { owner: me },
+                    ownership,
                 ),
             },
-            { owner: me },
+            ownership,
         );
 
         const map1 = await TestMap.load(map.id, meOnSecondPeer, {});
@@ -141,8 +142,7 @@ describe("Deep loading with depth arg", async () => {
             throw new Error("map4 is undefined");
         }
         expect(map4.list[0]?.stream).not.toBe(null);
-        // TODO: why is this actually defined?
-        // expect(map4.list[0]?.stream?.[me.id]).toBe(undefined)
+        expect(map4.list[0]?.stream?.[me.id]).not.toBe(null);
         expect(map4.list[0]?.stream?.byMe?.value).toBe(null);
 
         const map5 = await TestMap.load(map.id, meOnSecondPeer, {