jazz-tools 0.7.34-neverthrow.8 → 0.7.35-guest-auth.3

package/src/implementation/createContext.ts

@@ -0,0 +1,229 @@
+import {
+    AgentSecret,
+    CoID,
+    ControlledAgent,
+    CryptoProvider,
+    LocalNode,
+    Peer,
+    RawAccount,
+    RawAccountID,
+    SessionID,
+} from "cojson";
+import { Account, AccountClass, ID } from "../internal.js";
+
+export type AuthResult =
+    | {
+          type: "existing";
+          credentials: { accountID: ID<Account>; secret: AgentSecret };
+          onSuccess: () => void;
+          onError: (error: string | Error) => void;
+      }
+    | {
+          type: "new";
+          creationProps: { name: string };
+          initialSecret?: AgentSecret;
+          saveCredentials: (credentials: {
+              accountID: ID<Account>;
+              secret: AgentSecret;
+          }) => Promise<void>;
+          onSuccess: () => void;
+          onError: (error: string | Error) => void;
+      };
+
+export interface AuthMethod {
+    start(crypto: CryptoProvider): Promise<AuthResult>;
+}
+
+export const fixedCredentialsAuth = (credentials: {
+    accountID: ID<Account>;
+    secret: AgentSecret;
+}): AuthMethod => {
+    return {
+        start: async () => ({
+            type: "existing",
+            credentials,
+            onSuccess: () => {},
+            onError: () => {},
+        }),
+    };
+};
+
+export async function randomSessionProvider(
+    accountID: ID<Account>,
+    crypto: CryptoProvider,
+) {
+    return {
+        sessionID: crypto.newRandomSessionID(
+            accountID as unknown as RawAccountID,
+        ),
+        sessionDone: () => {},
+    };
+}
+
+type ContextParamsWithAuth<Acc extends Account> = {
+    AccountSchema?: AccountClass<Acc>;
+    auth: AuthMethod;
+    sessionProvider: (
+        accountID: ID<Account>,
+        crypto: CryptoProvider,
+    ) => Promise<{ sessionID: SessionID; sessionDone: () => void }>;
+} & BaseContextParams;
+
+type BaseContextParams = {
+    peersToLoadFrom: Peer[];
+    crypto: CryptoProvider;
+};
+
+export async function createJazzContext<Acc extends Account>({
+    AccountSchema,
+    auth,
+    sessionProvider,
+    peersToLoadFrom,
+    crypto,
+}: ContextParamsWithAuth<Acc>): Promise<{ account: Acc; done: () => void }>;
+export async function createJazzContext({
+    peersToLoadFrom,
+    crypto,
+}: BaseContextParams): Promise<{ agent: AnonymousJazzAgent; done: () => void }>;
+export async function createJazzContext<Acc extends Account>(
+    options: ContextParamsWithAuth<Acc> | BaseContextParams,
+): Promise<
+    | { account: Acc; done: () => void }
+    | { agent: AnonymousJazzAgent; done: () => void }
+>
+export async function createJazzContext<Acc extends Account>(
+    options: ContextParamsWithAuth<Acc> | BaseContextParams,
+): Promise<
+    | { account: Acc; done: () => void }
+    | { agent: AnonymousJazzAgent; done: () => void }
+> {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (!("auth" in options)) {
+            return createAnonymousJazzContext({
+                peersToLoadFrom: options.peersToLoadFrom,
+                crypto: options.crypto,
+            });
+        }
+
+        const { auth, sessionProvider, peersToLoadFrom, crypto } = options;
+        const AccountSchema =
+            options.AccountSchema ?? (Account as unknown as AccountClass<Acc>);
+
+        const authResult = await auth.start(crypto);
+
+        if (authResult.type === "existing") {
+            try {
+                const { sessionID, sessionDone } = await sessionProvider(
+                    authResult.credentials.accountID,
+                    crypto,
+                );
+
+                try {
+                    const node = await LocalNode.withLoadedAccount({
+                        accountID: authResult.credentials
+                            .accountID as unknown as CoID<RawAccount>,
+                        accountSecret: authResult.credentials.secret,
+                        sessionID: sessionID,
+                        peersToLoadFrom: peersToLoadFrom,
+                        crypto: crypto,
+                        migration: async (rawAccount, _node, creationProps) => {
+                            const account = new AccountSchema({
+                                fromRaw: rawAccount,
+                            }) as Acc;
+
+                            await account.migrate?.(creationProps);
+                        },
+                    });
+
+                    const account = AccountSchema.fromNode(node);
+                    authResult.onSuccess();
+
+                    return {
+                        account,
+                        done: () => {
+                            node.gracefulShutdown();
+                            sessionDone();
+                        },
+                    };
+                } catch (e) {
+                    authResult.onError(
+                        new Error("Error loading account", { cause: e }),
+                    );
+                    sessionDone();
+                }
+            } catch (e) {
+                authResult.onError(
+                    new Error("Error acquiring sessionID", { cause: e }),
+                );
+            }
+        } else if (authResult.type === "new") {
+            try {
+                // TODO: figure out a way to not "waste" the first SessionID
+                const { node } = await LocalNode.withNewlyCreatedAccount({
+                    creationProps: authResult.creationProps,
+                    peersToLoadFrom: peersToLoadFrom,
+                    crypto: crypto,
+                    initialAgentSecret: authResult.initialSecret,
+                    migration: async (rawAccount, _node, creationProps) => {
+                        const account = new AccountSchema({
+                            fromRaw: rawAccount,
+                        }) as Acc;
+
+                        await account.migrate?.(creationProps);
+                    },
+                });
+
+                const account = AccountSchema.fromNode(node);
+
+                await authResult.saveCredentials({
+                    accountID: node.account.id as unknown as ID<Account>,
+                    secret: node.account.agentSecret,
+                });
+
+                authResult.onSuccess();
+
+                return {
+                    account,
+                    done: () => {
+                        node.gracefulShutdown();
+                    },
+                };
+            } catch (e) {
+                authResult.onError(
+                    new Error("Error creating account", { cause: e }),
+                );
+            }
+        }
+    }
+}
+
+export class AnonymousJazzAgent {
+    constructor(public node: LocalNode) {}
+}
+
+export async function createAnonymousJazzContext({
+    peersToLoadFrom,
+    crypto,
+}: {
+    peersToLoadFrom: Peer[];
+    crypto: CryptoProvider;
+}): Promise<{ agent: AnonymousJazzAgent; done: () => void }> {
+    const agentSecret = crypto.newRandomAgentSecret();
+    const rawAgent = new ControlledAgent(agentSecret, crypto);
+
+    const node = new LocalNode(
+        rawAgent,
+        crypto.newRandomSessionID(rawAgent.id),
+        crypto,
+    );
+
+    for (const peer of peersToLoadFrom) {
+        node.syncManager.addPeer(peer);
+    }
+
+    return {
+        agent: new AnonymousJazzAgent(node),
+        done: () => {},
+    };
+}

package/src/implementation/refs.ts

@@ -1,6 +1,7 @@
 import type { CoID, RawCoValue } from "cojson";
 import type {
     Account,
+    AnonymousJazzAgent,
     CoValue,
     ID,
     RefEncoded,
@@ -19,7 +20,7 @@ const TRACE_ACCESSES = false;
 export class Ref<out V extends CoValue> {
     constructor(
         readonly id: ID<V>,
-        readonly controlledAccount: Account,
+        readonly controlledAccount: Account | AnonymousJazzAgent,
         readonly schema: RefEncoded<V>,
     ) {
         if (!isRefEncoded(schema)) {
@@ -28,9 +29,11 @@ export class Ref<out V extends CoValue> {
     }
 
     get value() {
-        const raw = this.controlledAccount._raw.core.node.getLoaded(
-            this.id as unknown as CoID<RawCoValue>,
-        );
+        const node =
+            "node" in this.controlledAccount
+                ? this.controlledAccount.node
+                : this.controlledAccount._raw.core.node;
+        const raw = node.getLoaded(this.id as unknown as CoID<RawCoValue>);
         if (raw) {
             let value = refCache.get(raw);
             if (value) {
@@ -48,7 +51,11 @@ export class Ref<out V extends CoValue> {
     private async loadHelper(options?: {
         onProgress: (p: number) => void;
     }): Promise<V | "unavailable"> {
-        const raw = await this.controlledAccount._raw.core.node.load(
+        const node =
+            "node" in this.controlledAccount
+                ? this.controlledAccount.node
+                : this.controlledAccount._raw.core.node;
+        const raw = await node.load(
             this.id as unknown as CoID<RawCoValue>,
             options?.onProgress,
         );

package/src/index.ts

@@ -11,6 +11,7 @@ export type {
     AgentID,
     SyncMessage,
     CryptoProvider,
+    CoValueUniqueness,
 } from "cojson";
 
 export type { ID, CoValue } from "./internal.js";
@@ -21,9 +22,18 @@ 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 } from "./internal.js";
+export { Account, isControlledAccount, type AccountClass } 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,
+    AnonymousJazzAgent,
+    createAnonymousJazzContext,
+} from "./internal.js";

package/src/internal.ts

@@ -16,4 +16,6 @@ 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,14 +1,16 @@
 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();
 
@@ -169,12 +171,13 @@ describe("CoList resolution", async () => {
             throw "me is not a controlled account";
         }
         me._raw.core.node.syncManager.addPeer(secondPeer);
-        const meOnSecondPeer = await Account.become({
-            accountID: me.id,
-            accountSecret: me._raw.agentSecret,
+        const { account: meOnSecondPeer } = await createJazzContext({
+            auth: fixedCredentialsAuth({
+                accountID: me.id,
+                secret: me._raw.agentSecret,
+            }),
+            sessionProvider: randomSessionProvider,
             peersToLoadFrom: [initialAsPeer],
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -192,7 +195,11 @@ 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);
-        expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
+        // TODO: this should be ref equal
+        // expect(loadedList?._refs[0]?.value).toEqual(loadedNestedList);
+        expect(loadedList?._refs[0]?.value?.toJSON()).toEqual(
+            loadedNestedList?.toJSON(),
+        );
 
         const loadedTwiceNestedList = await TwiceNestedList.load(
             list[0]![0]!.id,
@@ -204,7 +211,11 @@ 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);
-        expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
+        // TODO: this should be ref equal
+        // expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
+        expect(loadedList?.[0]?._refs[0]?.value?.toJSON()).toEqual(
+            loadedTwiceNestedList?.toJSON(),
+        );
 
         const otherNestedList = NestedList.create(
             [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
@@ -212,7 +223,11 @@ describe("CoList resolution", async () => {
         );
 
         loadedList![0] = otherNestedList;
-        expect(loadedList?.[0]).toEqual(otherNestedList);
+        // TODO: this should be ref equal
+        // expect(loadedList?.[0]).toEqual(otherNestedList);
+        expect(loadedList?._refs[0]?.value?.toJSON()).toEqual(
+            otherNestedList.toJSON(),
+        );
         expect(loadedList?._refs[0]?.id).toEqual(otherNestedList.id);
     });
 
@@ -231,12 +246,13 @@ describe("CoList resolution", async () => {
             throw "me is not a controlled account";
         }
         me._raw.core.node.syncManager.addPeer(secondPeer);
-        const meOnSecondPeer = await Account.become({
-            accountID: me.id,
-            accountSecret: me._raw.agentSecret,
+        const { account: meOnSecondPeer } = await createJazzContext({
+            auth: fixedCredentialsAuth({
+                accountID: me.id,
+                secret: me._raw.agentSecret,
+            }),
+            sessionProvider: randomSessionProvider,
             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,6 +1,5 @@
 import { expect, describe, test } from "vitest";
 import { connectedPeers } from "cojson/src/streamUtils.js";
-import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import {
     Account,
     Encoders,
@@ -9,32 +8,35 @@ 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();
@@ -284,22 +286,26 @@ describe("CoMap resolution", async () => {
 
     test("Loading and availability", async () => {
         const { me, map } = await initNodeAndMap();
-        const [initialAsPeer, secondPeer] =
-            connectedPeers("initial", "second", {
+        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 meOnSecondPeer = await Account.become({
-            accountID: me.id,
-            accountSecret: me._raw.agentSecret,
+        const { account: meOnSecondPeer } = await createJazzContext({
+            auth: fixedCredentialsAuth({
+                accountID: me.id,
+                secret: me._raw.agentSecret,
+            }),
+            sessionProvider: randomSessionProvider,
             peersToLoadFrom: [initialAsPeer],
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
@@ -355,89 +361,87 @@ describe("CoMap resolution", async () => {
     test("Subscription & auto-resolution", async () => {
         const { me, map } = await initNodeAndMap();
 
-        const [initialAsPeer, secondAsPeer] =
-            connectedPeers("initial", "second", {
+        const [initialAsPeer, secondAsPeer] = connectedPeers(
+            "initial",
+            "second",
+            {
                 peer1role: "server",
                 peer2role: "client",
-            });
+            },
+        );
 
         if (!isControlledAccount(me)) {
             throw "me is not a controlled account";
         }
         me._raw.core.node.syncManager.addPeer(secondAsPeer);
-        const meOnSecondPeer = await Account.become({
-            accountID: me.id,
-            accountSecret: me._raw.agentSecret,
+        const { account: meOnSecondPeer } = await createJazzContext({
+            auth: fixedCredentialsAuth({
+                accountID: me.id,
+                secret: me._raw.agentSecret,
+            }),
+            sessionProvider: randomSessionProvider,
             peersToLoadFrom: [initialAsPeer],
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            sessionID: newRandomSessionID(me.id as any),
             crypto: Crypto,
         });
 
+        const queue = new cojsonInternals.Channel<TestMap>();
 
-                const queue = new cojsonInternals.Channel<TestMap>();
-
-                TestMap.subscribe(
-                    map.id,
-                    meOnSecondPeer,
-                    {},
-                    (subscribedMap) => {
-                        console.log(
-                            "subscribedMap.nested?.twiceNested?.taste",
-                            subscribedMap.nested?.twiceNested?.taste,
-                        );
-                        void queue.push(subscribedMap);
-                    },
-                );
+        TestMap.subscribe(map.id, meOnSecondPeer, {}, (subscribedMap) => {
+            console.log(
+                "subscribedMap.nested?.twiceNested?.taste",
+                subscribedMap.nested?.twiceNested?.taste,
+            );
+            void queue.push(subscribedMap);
+        });
 
-                const update1 = (await queue.next()).value;
-                expect(update1.nested).toEqual(null);
+        const update1 = (await queue.next()).value;
+        expect(update1.nested).toEqual(null);
 
-                const update2 = (await queue.next()).value;
-                expect(update2.nested?.name).toEqual("nested");
+        const update2 = (await queue.next()).value;
+        expect(update2.nested?.name).toEqual("nested");
 
-                map.nested!.name = "nestedUpdated";
+        map.nested!.name = "nestedUpdated";
 
-                const _ = (await queue.next()).value;
-                const update3 = (await queue.next()).value;
-                expect(update3.nested?.name).toEqual("nestedUpdated");
+        const _ = (await queue.next()).value;
+        const update3 = (await queue.next()).value;
+        expect(update3.nested?.name).toEqual("nestedUpdated");
 
-                const oldTwiceNested = update3.nested!.twiceNested;
-                expect(oldTwiceNested?.taste).toEqual("sour");
+        const oldTwiceNested = update3.nested!.twiceNested;
+        expect(oldTwiceNested?.taste).toEqual("sour");
 
-                // When assigning a new nested value, we get an update
-                const newTwiceNested = TwiceNestedMap.create(
-                    {
-                        taste: "sweet",
-                    },
-                    { owner: meOnSecondPeer },
-                );
+        // When assigning a new nested value, we get an update
+        const newTwiceNested = TwiceNestedMap.create(
+            {
+                taste: "sweet",
+            },
+            { owner: meOnSecondPeer },
+        );
 
-                const newNested = NestedMap.create(
-                    {
-                        name: "newNested",
-                        twiceNested: newTwiceNested,
-                    },
-                    { owner: meOnSecondPeer },
-                );
+        const newNested = NestedMap.create(
+            {
+                name: "newNested",
+                twiceNested: newTwiceNested,
+            },
+            { owner: meOnSecondPeer },
+        );
 
-                update3.nested = newNested;
+        update3.nested = newNested;
 
-                (await queue.next()).value;
-                // const update4 = (await queue.next()).value;
-                const update4b = (await queue.next()).value;
+        (await queue.next()).value;
+        // const update4 = (await queue.next()).value;
+        const update4b = (await queue.next()).value;
 
-                expect(update4b.nested?.name).toEqual("newNested");
-                expect(update4b.nested?.twiceNested?.taste).toEqual("sweet");
+        expect(update4b.nested?.name).toEqual("newNested");
+        expect(update4b.nested?.twiceNested?.taste).toEqual("sweet");
 
-                // we get updates when the new nested value changes
-                newTwiceNested.taste = "salty";
-                const update5 = (await queue.next()).value;
-                expect(update5.nested?.twiceNested?.taste).toEqual("salty");
+        // we get updates when the new nested value changes
+        newTwiceNested.taste = "salty";
+        const update5 = (await queue.next()).value;
+        expect(update5.nested?.twiceNested?.taste).toEqual("salty");
 
-                newTwiceNested.taste = "umami";
-                const update6 = (await queue.next()).value;
-                expect(update6.nested?.twiceNested?.taste).toEqual("umami");
+        newTwiceNested.taste = "umami";
+        const update6 = (await queue.next()).value;
+        expect(update6.nested?.twiceNested?.taste).toEqual("umami");
     });
 
     class TestMapWithOptionalRef extends CoMap {
@@ -734,3 +738,28 @@ describe("CoMap applyDiff", async () => {
         expect((map as any).invalidField).toBeUndefined();
     });
 });
+
+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,
+        });
+
+        const group = await Group.create({
+            owner: me,
+        });
+
+        const alice = TestMap.create({
+            name: "Alice",
+            _height: 100,
+            birthday: new Date("1990-01-01"),
+            color: "red",
+
+        }, { owner: group, unique: { name: "Alice" } });
+
+        const foundAlice = TestMap.findUnique({ name: "Alice" }, group.id, me);
+
+        expect(foundAlice).toEqual(alice.id);
+    });
+});