jazz-tools 0.7.35-unique.2 → 0.7.35

package/src/coValues/interfaces.ts

@@ -63,11 +63,11 @@ type IDMarker<out T> = { __type(_: never): T };
 
 /** @internal */
 export class CoValueBase implements CoValue {
-    declare id: ID<this>;
-    declare _type: string;
-    declare _raw: RawCoValue;
+    id!: ID<this>;
+    _type!: string;
+    _raw!: RawCoValue;
     /** @category Internals */
-    declare _instanceID: string;
+    _instanceID!: string;
 
     get _owner(): Account | Group {
         const owner =

package/src/implementation/devtoolsFormatters.ts

@@ -1,3 +1,4 @@
+/* istanbul ignore file -- @preserve */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ItemsSym } from "./symbols.js";
 

package/src/implementation/schema.ts

@@ -88,6 +88,7 @@ function optionalRef<C extends CoValueClass>(
 
 function ref<C extends CoValueClass>(
     arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+    options?: never,
 ): co<InstanceType<C> | null>;
 function ref<C extends CoValueClass>(
     arg: C | ((_raw: InstanceType<C>["_raw"]) => C),

package/src/index.ts

@@ -11,7 +11,6 @@ export type {
     AgentID,
     SyncMessage,
     CryptoProvider,
-    CoValueUniqueness,
 } from "cojson";
 
 export type { ID, CoValue } from "./internal.js";
@@ -22,16 +21,9 @@ export { CoMap, type CoMapInit } from "./internal.js";
 export { CoList } from "./internal.js";
 export { CoStream, BinaryCoStream } from "./internal.js";
 export { Group, Profile } from "./internal.js";
-export { Account, isControlledAccount, type AccountClass } from "./internal.js";
+export { Account, isControlledAccount } from "./internal.js";
 export { ImageDefinition } from "./internal.js";
 export { CoValueBase, type CoValueClass } from "./internal.js";
 export type { DepthsIn, DeeplyLoaded } from "./internal.js";
 
 export { loadCoValue, subscribeToCoValue } from "./internal.js";
-
-export {
-    type AuthMethod,
-    type AuthResult,
-    createJazzContext,
-    fixedCredentialsAuth,
-} from "./internal.js";

package/src/internal.ts

@@ -16,6 +16,4 @@ export * from "./coValues/deepLoading.js";
 
 export * from "./coValues/extensions/imageDef.js";
 
-export * from "./implementation/createContext.js";
-
 import "./implementation/devtoolsFormatters.js";

package/src/tests/coList.test.ts

@@ -1,16 +1,14 @@
 import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
+import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import {
     Account,
     CoList,
     WasmCrypto,
     co,
     cojsonInternals,
-    createJazzContext,
     isControlledAccount,
-    fixedCredentialsAuth,
 } from "../index.js";
-import { randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -171,13 +169,12 @@ 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -195,11 +192,7 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]).toBeDefined();
         expect(loadedList?.[0]?.[0]).toBe(null);
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]![0]!.id);
-        // TODO: this should be ref equal
-        // expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
-        expect(loadedList?._refs[0]?.value?.toJSON()).toEqual(
-            loadedNestedList?.toJSON(),
-        );
+        expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
 
         const loadedTwiceNestedList = await TwiceNestedList.load(
             list[0]![0]!.id,
@@ -211,11 +204,7 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?.[0]?.[0]).toBe("a");
         expect(loadedList?.[0]?.[0]?.joined()).toBe("a,b");
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
-        // TODO: this should be ref equal
-        // expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
-        expect(loadedList?.[0]?._refs[0]?.value?.toJSON()).toEqual(
-            loadedTwiceNestedList?.toJSON(),
-        );
+        expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
         const otherNestedList = NestedList.create(
             [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
@@ -223,11 +212,7 @@ describe("CoList resolution", async () => {
         );
 
         loadedList![0] = otherNestedList;
-        // TODO: this should be ref equal
-        // expect(loadedList?.[0]).toEqual(otherNestedList);
-        expect(loadedList?._refs[0]?.value?.toJSON()).toEqual(
-            otherNestedList.toJSON(),
-        );
+        expect(loadedList?.[0]).toEqual(otherNestedList);
         expect(loadedList?._refs[0]?.id).toEqual(otherNestedList.id);
     });
 
@@ -246,13 +231,12 @@ 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 

package/src/tests/coMap.test.ts

@@ -1,5 +1,6 @@
-import { expect, describe, test } from "vitest";
+import { expect, describe, test, expectTypeOf } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
+import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import {
     Account,
     Encoders,
@@ -8,35 +9,32 @@ import {
     WasmCrypto,
     isControlledAccount,
     cojsonInternals,
-    createJazzContext,
-    fixedCredentialsAuth,
 } from "../index.js";
-import { Group, randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
-class TestMap extends CoMap {
-    color = co.string;
-    _height = co.number;
-    birthday = co.encoded(Encoders.Date);
-    name? = co.string;
-    nullable = co.optional.encoded<string | undefined>({
-        encode: (value: string | undefined) => value || null,
-        decode: (value: unknown) => (value as string) || undefined,
-    });
-    optionalDate = co.optional.encoded(Encoders.Date);
-
-    get roughColor() {
-        return this.color + "ish";
-    }
-}
-
 describe("Simple CoMap operations", async () => {
     const me = await Account.create({
         creationProps: { name: "Hermes Puggington" },
         crypto: Crypto,
     });
 
+    class TestMap extends CoMap {
+        color = co.string;
+        _height = co.number;
+        birthday = co.encoded(Encoders.Date);
+        name? = co.string;
+        nullable = co.optional.encoded<string | undefined>({
+            encode: (value: string | undefined) => value || null,
+            decode: (value: unknown) => (value as string) || undefined,
+        });
+        optionalDate = co.optional.encoded(Encoders.Date);
+
+        get roughColor() {
+            return this.color + "ish";
+        }
+    }
+
     console.log("TestMap schema", TestMap.prototype._schema);
 
     const birthday = new Date();
@@ -299,13 +297,12 @@ 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -374,13 +371,12 @@ 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -592,6 +588,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,29 +734,141 @@ 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("Creating and finding unique CoMaps", async () => {
-    test("Creating and finding unique CoMaps", async () => {
-        const me = await Account.create({
-            creationProps: { name: "Tester McTesterson" },
-            crypto: Crypto,
-        });
+describe("CoMap Typescript validation", async () => {
+    const me = await Account.create({
+        creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
+    });
 
-        const group = await Group.create({
-            owner: me,
-        });
+    test("Is not ok to pass null into a required ref", () => {
+        class TestMap extends CoMap {
+            required = co.ref(NestedMap);
+            optional = co.optional.ref(NestedMap);
+        }
 
-        const alice = TestMap.create({
-            name: "Alice",
-            _height: 100,
-            birthday: new Date("1990-01-01"),
-            color: "red",
+        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 },
+        );
+    });
 
-        }, { owner: group, unique: { name: "Alice" } });
+    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 },
+        );
 
-        const foundAlice = TestMap.findUnique({ name: "Alice" }, group.id, 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 },
+        );
 
-        expect(foundAlice).toEqual(alice.id);
+        expectTypeOf(map.required).toBeNullable();
     });
 });

package/src/tests/coStream.test.ts

@@ -1,5 +1,6 @@
 import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
+import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import {
     BinaryCoStream,
     ID,
@@ -9,10 +10,7 @@ import {
     WasmCrypto,
     isControlledAccount,
     cojsonInternals,
-    createJazzContext,
-    fixedCredentialsAuth,
 } from "../index.js";
-import { randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -97,13 +95,12 @@ describe("CoStream 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -194,13 +191,12 @@ describe("CoStream 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -338,13 +334,12 @@ describe("BinaryCoStream 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -374,13 +369,12 @@ describe("BinaryCoStream 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,
+        const meOnSecondPeer = await Account.become({
+            accountID: me.id,
+            accountSecret: me._raw.agentSecret,
             peersToLoadFrom: [initialAsPeer],
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -443,3 +437,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

@@ -12,10 +12,8 @@ import {
     Profile,
     isControlledAccount,
     ID,
-    createJazzContext,
-    fixedCredentialsAuth,
 } from "../index.js";
-import { randomSessionProvider } from "../internal.js";
+import { newRandomSessionID } from "cojson/src/coValueCore.js";
 
 class TestMap extends CoMap {
     list = co.ref(TestList);
@@ -49,17 +47,17 @@ describe("Deep loading with depth arg", 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,
+    const meOnSecondPeer = await Account.become({
+        accountID: me.id,
+        accountSecret: me._raw.agentSecret,
         peersToLoadFrom: [initialAsPeer],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        sessionID: newRandomSessionID(me.id as any),
         crypto: Crypto,
     });
 
     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 +68,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 +139,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, {
@@ -266,13 +263,12 @@ test("Deep loading a record-like coMap", async () => {
     }
 
     me._raw.core.node.syncManager.addPeer(secondPeer);
-    const { account: meOnSecondPeer } = await createJazzContext({
-        auth: fixedCredentialsAuth({
-            accountID: me.id,
-            secret: me._raw.agentSecret,
-        }),
-        sessionProvider: randomSessionProvider,
+    const meOnSecondPeer = await Account.become({
+        accountID: me.id,
+        accountSecret: me._raw.agentSecret,
         peersToLoadFrom: [initialAsPeer],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        sessionID: newRandomSessionID(me.id as any),
         crypto: Crypto,
     });
 

package/tsconfig.json

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "lib": ["ESNext"],
     "module": "esnext",
-    "target": "es2022",
+    "target": "ES2020",
     "moduleResolution": "bundler",
     "moduleDetection": "force",
     "strict": true,