jazz-tools 0.9.23 → 0.10.0

package/src/implementation/ContextManager.ts

@@ -0,0 +1,178 @@
+import { AgentSecret, LocalNode, cojsonInternals } from "cojson";
+import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
+import { InMemoryKVStore } from "../auth/InMemoryKVStore.js";
+import { KvStore, KvStoreContext } from "../auth/KvStoreContext.js";
+import { Account } from "../coValues/account.js";
+import { AuthCredentials } from "../types.js";
+import { JazzContextType } from "../types.js";
+import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
+
+export type JazzContextManagerAuthProps = {
+  credentials?: AuthCredentials;
+  newAccountProps?: { secret: AgentSecret; creationProps: { name: string } };
+};
+
+export type JazzContextManagerBaseProps<Acc extends Account> = {
+  onAnonymousAccountDiscarded?: (anonymousAccount: Acc) => Promise<void>;
+  onLogOut?: () => void;
+};
+
+type PlatformSpecificAuthContext<Acc extends Account> = {
+  me: Acc;
+  node: LocalNode;
+  logOut: () => Promise<void>;
+  done: () => void;
+};
+
+type PlatformSpecificGuestContext = {
+  guest: AnonymousJazzAgent;
+  node: LocalNode;
+  logOut: () => Promise<void>;
+  done: () => void;
+};
+
+type PlatformSpecificContext<Acc extends Account> =
+  | PlatformSpecificAuthContext<Acc>
+  | PlatformSpecificGuestContext;
+
+export class JazzContextManager<
+  Acc extends Account,
+  P extends JazzContextManagerBaseProps<Acc>,
+> {
+  protected value: JazzContextType<Acc> | undefined;
+  protected context: PlatformSpecificContext<Acc> | undefined;
+  protected props: P | undefined;
+  protected authSecretStorage = new AuthSecretStorage();
+  protected authenticating = false;
+
+  constructor() {
+    KvStoreContext.getInstance().initialize(this.getKvStore());
+  }
+
+  getKvStore(): KvStore {
+    return new InMemoryKVStore();
+  }
+
+  async createContext(props: P, authProps?: JazzContextManagerAuthProps) {
+    props;
+    authProps;
+    throw new Error("Not implemented");
+  }
+
+  updateContext(props: P, context: PlatformSpecificContext<Acc>) {
+    // When authenticating we don't want to close the previous context
+    // because we might need to handle the onAnonymousAccountDiscarded callback
+    if (!this.authenticating) {
+      this.context?.done();
+    }
+
+    this.context = context;
+    this.props = props;
+    this.value = {
+      ...context,
+      node: context.node,
+      authenticate: this.authenticate,
+      logOut: this.logOut,
+    };
+
+    this.notify();
+  }
+
+  propsChanged(props: P) {
+    props;
+    throw new Error("Not implemented");
+  }
+
+  getCurrentValue() {
+    return this.value;
+  }
+
+  getAuthSecretStorage() {
+    return this.authSecretStorage;
+  }
+
+  logOut = async () => {
+    if (!this.context || !this.props) {
+      return;
+    }
+
+    await this.context.logOut();
+    this.props.onLogOut?.();
+    return this.createContext(this.props);
+  };
+
+  done = () => {
+    if (!this.context) {
+      return;
+    }
+
+    this.context.done();
+  };
+
+  authenticate = async (credentials: AuthCredentials) => {
+    if (!this.props) {
+      throw new Error("Props required");
+    }
+
+    const prevContext = this.context;
+    const prevCredentials = await this.authSecretStorage.get();
+    const wasAnonymous =
+      this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+
+    this.authenticating = true;
+    await this.createContext(this.props, { credentials }).finally(() => {
+      this.authenticating = false;
+    });
+
+    const currentContext = this.context;
+
+    if (
+      prevContext &&
+      currentContext &&
+      "me" in prevContext &&
+      "me" in currentContext &&
+      wasAnonymous
+    ) {
+      // Using a direct connection to make coValue transfer almost synchronous
+      const [prevAccountAsPeer, currentAccountAsPeer] =
+        cojsonInternals.connectedPeers(
+          prevContext.me.id,
+          currentContext.me.id,
+          {
+            peer1role: "client",
+            peer2role: "server",
+          },
+        );
+
+      prevContext.node.syncManager.addPeer(currentAccountAsPeer);
+      currentContext.node.syncManager.addPeer(prevAccountAsPeer);
+
+      try {
+        await this.props.onAnonymousAccountDiscarded?.(prevContext.me);
+        await prevContext.me.waitForAllCoValuesSync();
+      } catch (error) {
+        console.error("Error onAnonymousAccountDiscarded", error);
+      }
+
+      prevAccountAsPeer.outgoing.close();
+      currentAccountAsPeer.outgoing.close();
+    }
+
+    prevContext?.done();
+  };
+
+  listeners = new Set<() => void>();
+  subscribe = (callback: () => void) => {
+    this.listeners.add(callback);
+
+    return () => {
+      this.listeners.delete(callback);
+    };
+  };
+
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+}

package/src/implementation/activeAccountContext.ts

@@ -4,15 +4,20 @@ class ActiveAccountContext {
   private activeAccount: Account | null = null;
   private guestMode: boolean = false;
 
-  set(account: Account) {
+  set(account: Account | null) {
     this.activeAccount = account;
     this.guestMode = false;
   }
 
   setGuestMode() {
+    this.activeAccount = null;
     this.guestMode = true;
   }
 
+  maybeGet() {
+    return this.activeAccount;
+  }
+
   get() {
     if (!this.activeAccount) {
       if (this.guestMode) {

package/src/implementation/createContext.ts

@@ -9,9 +9,11 @@ import {
   RawAccountID,
   SessionID,
 } from "cojson";
+import { AuthSecretStorage } from "../auth/AuthSecretStorage.js";
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import type { ID } from "../internal.js";
+import { AuthCredentials, NewAccountProps } from "../types.js";
 import { activeAccountContext } from "./activeAccountContext.js";
 import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 
@@ -20,14 +22,20 @@ export type Credentials = {
   secret: AgentSecret;
 };
 
+type SessionProvider = (
+  accountID: ID<Account>,
+  crypto: CryptoProvider,
+) => Promise<{ sessionID: SessionID; sessionDone: () => void }>;
+
 export type AuthResult =
   | {
       type: "existing";
+      username?: string;
       credentials: Credentials;
       saveCredentials?: (credentials: Credentials) => Promise<void>;
       onSuccess: () => void;
       onError: (error: string | Error) => void;
-      logOut: () => void;
+      logOut: () => Promise<void>;
     }
   | {
       type: "new";
@@ -40,42 +48,9 @@ export type AuthResult =
       saveCredentials: (credentials: Credentials) => Promise<void>;
       onSuccess: () => void;
       onError: (error: string | Error) => void;
-      logOut: () => void;
+      logOut: () => Promise<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,
-      saveCredentials: async () => {},
-      onSuccess: () => {},
-      onError: () => {},
-      logOut: () => {},
-    }),
-  };
-};
-
-export const ephemeralCredentialsAuth = (): AuthMethod => {
-  return {
-    start: async () => ({
-      type: "new",
-      creationProps: { name: "Ephemeral" },
-      saveCredentials: async () => {},
-      onSuccess: () => {},
-      onError: () => {},
-      logOut: () => {},
-    }),
-  };
-};
-
 export async function randomSessionProvider(
   accountID: ID<Account>,
   crypto: CryptoProvider,
@@ -86,152 +61,201 @@ export async function randomSessionProvider(
   };
 }
 
-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 type JazzContextWithAccount<Acc extends Account> = {
+  node: LocalNode;
   account: Acc;
   done: () => void;
-  logOut: () => void;
+  logOut: () => Promise<void>;
 };
 
 export type JazzContextWithAgent = {
   agent: AnonymousJazzAgent;
   done: () => void;
-  logOut: () => void;
+  logOut: () => Promise<void>;
 };
 
 export type JazzContext<Acc extends Account> =
   | JazzContextWithAccount<Acc>
   | JazzContextWithAgent;
 
-export async function createJazzContext<Acc extends Account>({
-  AccountSchema,
-  auth,
-  sessionProvider,
+export async function createJazzContextFromExistingCredentials<
+  Acc extends Account,
+>({
+  credentials,
   peersToLoadFrom,
   crypto,
-}: ContextParamsWithAuth<Acc>): Promise<JazzContextWithAccount<Acc>>;
-export async function createJazzContext({
+  AccountSchema: PropsAccountSchema,
+  sessionProvider,
+  onLogOut,
+}: {
+  credentials: Credentials;
+  peersToLoadFrom: Peer[];
+  crypto: CryptoProvider;
+  AccountSchema?: AccountClass<Acc>;
+  sessionProvider: SessionProvider;
+  onLogOut?: () => void;
+}): Promise<JazzContextWithAccount<Acc>> {
+  const { sessionID, sessionDone } = await sessionProvider(
+    credentials.accountID,
+    crypto,
+  );
+
+  const CurrentAccountSchema =
+    PropsAccountSchema ??
+    (RegisteredSchemas["Account"] as unknown as AccountClass<Acc>);
+
+  const node = await LocalNode.withLoadedAccount({
+    accountID: credentials.accountID as unknown as CoID<RawAccount>,
+    accountSecret: credentials.secret,
+    sessionID: sessionID,
+    peersToLoadFrom: peersToLoadFrom,
+    crypto: crypto,
+  });
+
+  const account = CurrentAccountSchema.fromNode(node);
+  activeAccountContext.set(account);
+
+  // Running the migration outside of withLoadedAccount for better error management
+  await account.applyMigration();
+
+  return {
+    node,
+    account,
+    done: () => {
+      node.gracefulShutdown();
+      sessionDone();
+    },
+    logOut: async () => {
+      node.gracefulShutdown();
+      sessionDone();
+      await onLogOut?.();
+    },
+  };
+}
+
+export async function createJazzContextForNewAccount<Acc extends Account>({
+  creationProps,
+  initialAgentSecret,
   peersToLoadFrom,
   crypto,
-}: BaseContextParams): Promise<JazzContextWithAgent>;
-export async function createJazzContext<Acc extends Account>(
-  options: ContextParamsWithAuth<Acc> | BaseContextParams,
-): Promise<JazzContext<Acc>>;
-export async function createJazzContext<Acc extends Account>(
-  options: ContextParamsWithAuth<Acc> | BaseContextParams,
-): Promise<JazzContext<Acc> | JazzContextWithAgent> {
-  if (!("auth" in options)) {
-    return createAnonymousJazzContext({
-      peersToLoadFrom: options.peersToLoadFrom,
-      crypto: options.crypto,
-    });
-  }
-
-  const { auth, sessionProvider, peersToLoadFrom, crypto } = options;
-  const AccountSchema =
-    options.AccountSchema ??
+  AccountSchema: PropsAccountSchema,
+  onLogOut,
+}: {
+  creationProps: { name: string };
+  initialAgentSecret?: AgentSecret;
+  peersToLoadFrom: Peer[];
+  crypto: CryptoProvider;
+  AccountSchema?: AccountClass<Acc>;
+  onLogOut?: () => Promise<void>;
+}): Promise<JazzContextWithAccount<Acc>> {
+  const CurrentAccountSchema =
+    PropsAccountSchema ??
     (RegisteredSchemas["Account"] as unknown as AccountClass<Acc>);
-  const authResult = await auth.start(crypto);
 
-  if (authResult.type === "existing") {
-    const { sessionID, sessionDone } = await sessionProvider(
-      authResult.credentials.accountID,
-      crypto,
-    );
-
-    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;
-
-        activeAccountContext.set(account);
-
-        await account.applyMigration(creationProps);
-      },
-    });
+  const { node } = await LocalNode.withNewlyCreatedAccount({
+    creationProps,
+    peersToLoadFrom,
+    crypto,
+    initialAgentSecret,
+    migration: async (rawAccount, _node, creationProps) => {
+      const account = new CurrentAccountSchema({
+        fromRaw: rawAccount,
+      }) as Acc;
+      activeAccountContext.set(account);
 
-    const account = AccountSchema.fromNode(node);
-    activeAccountContext.set(account);
+      await account.applyMigration(creationProps);
+    },
+  });
 
-    if (authResult.saveCredentials) {
-      await authResult.saveCredentials({
-        accountID: node.account.id as unknown as ID<Account>,
-        secret: node.account.agentSecret,
-      });
-    }
+  const account = CurrentAccountSchema.fromNode(node);
+  activeAccountContext.set(account);
+
+  return {
+    node,
+    account,
+    done: () => {
+      node.gracefulShutdown();
+    },
+    logOut: async () => {
+      node.gracefulShutdown();
+      await onLogOut?.();
+    },
+  };
+}
 
-    authResult.onSuccess();
+export async function createJazzContext<Acc extends Account>(options: {
+  credentials?: AuthCredentials;
+  newAccountProps?: NewAccountProps;
+  peersToLoadFrom: Peer[];
+  crypto: CryptoProvider;
+  defaultProfileName?: string;
+  AccountSchema?: AccountClass<Acc>;
+  sessionProvider: SessionProvider;
+  authSecretStorage: AuthSecretStorage;
+}) {
+  const crypto = options.crypto;
 
-    return {
-      account,
-      done: () => {
-        node.gracefulShutdown();
-        sessionDone();
-      },
-      logOut: () => {
-        node.gracefulShutdown();
-        sessionDone();
-        authResult.logOut();
+  let context: JazzContextWithAccount<Acc>;
+
+  const authSecretStorage = options.authSecretStorage;
+
+  await authSecretStorage.migrate();
+
+  const credentials = options.credentials ?? (await authSecretStorage.get());
+
+  if (credentials && !options.newAccountProps) {
+    context = await createJazzContextFromExistingCredentials({
+      credentials: {
+        accountID: credentials.accountID,
+        secret: credentials.accountSecret,
       },
-    };
-  } else if (authResult.type === "new") {
-    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;
-        activeAccountContext.set(account);
-
-        await account.applyMigration(creationProps);
+      peersToLoadFrom: options.peersToLoadFrom,
+      crypto,
+      AccountSchema: options.AccountSchema,
+      sessionProvider: options.sessionProvider,
+      onLogOut: () => {
+        authSecretStorage.clear();
       },
     });
 
-    const account = AccountSchema.fromNode(node);
-    activeAccountContext.set(account);
+    // To align the isAuthenticated state with the credentials
+    authSecretStorage.emitUpdate(credentials);
+  } else {
+    const secretSeed = options.crypto.newRandomSecretSeed();
 
-    await authResult.saveCredentials({
-      accountID: node.account.id as unknown as ID<Account>,
-      secret: node.account.agentSecret,
-    });
+    const initialAgentSecret =
+      options.newAccountProps?.secret ??
+      crypto.agentSecretFromSecretSeed(secretSeed);
 
-    authResult.onSuccess();
-    return {
-      account,
-      done: () => {
-        node.gracefulShutdown();
-      },
-      logOut: () => {
-        node.gracefulShutdown();
-        authResult.logOut();
-      },
+    const creationProps = options.newAccountProps?.creationProps ?? {
+      name: options.defaultProfileName ?? "Anonymous user",
     };
+
+    context = await createJazzContextForNewAccount({
+      creationProps,
+      initialAgentSecret,
+      peersToLoadFrom: options.peersToLoadFrom,
+      crypto,
+      AccountSchema: options.AccountSchema,
+      onLogOut: async () => {
+        await authSecretStorage.clear();
+      },
+    });
+
+    if (!options.newAccountProps) {
+      await authSecretStorage.set({
+        accountID: context.account.id,
+        secretSeed,
+        accountSecret: context.node.account.agentSecret,
+        provider: "anonymous",
+      });
+    }
   }
 
-  throw new Error("Invalid auth result");
+  return {
+    ...context,
+    authSecretStorage,
+  };
 }
 
 export async function createAnonymousJazzContext({
@@ -259,6 +283,6 @@ export async function createAnonymousJazzContext({
   return {
     agent: new AnonymousJazzAgent(node),
     done: () => {},
-    logOut: () => {},
+    logOut: async () => {},
   };
 }