jazz-tools 0.14.27 → 0.15.0

package/src/svelte/jazz.svelte.ts

@@ -0,0 +1,109 @@
+import type {
+  AccountClass,
+  AuthSecretStorage,
+  CoValueOrZodSchema,
+  ID,
+  InstanceOfSchema,
+  JazzContextType,
+} from "jazz-tools";
+import { Account } from "jazz-tools";
+import { consumeInviteLinkFromWindowLocation } from "jazz-tools/browser";
+import { getContext, untrack } from "svelte";
+import Provider from "./Provider.svelte";
+
+export { Provider as JazzSvelteProvider };
+
+/**
+ * The key for the Jazz context.
+ */
+export const JAZZ_CTX = {};
+export const JAZZ_AUTH_CTX = {};
+
+/**
+ * The Jazz context.
+ */
+export type JazzContext<Acc extends Account> = {
+  current?: JazzContextType<Acc>;
+};
+
+/**
+ * Get the current Jazz context.
+ * @returns The current Jazz context.
+ */
+export function getJazzContext<Acc extends Account>() {
+  const context = getContext<JazzContext<Acc>>(JAZZ_CTX);
+
+  if (!context) {
+    throw new Error("useJazzContext must be used within a JazzSvelteProvider");
+  }
+
+  if (!context.current) {
+    throw new Error("Jazz context is not initialized");
+  }
+
+  return context as {
+    current: JazzContextType<Acc>;
+  };
+}
+
+export function getAuthSecretStorage() {
+  const context = getContext<AuthSecretStorage>(JAZZ_AUTH_CTX);
+
+  if (!context) {
+    throw new Error(
+      "getAuthSecretStorage must be used within a JazzSvelteProvider",
+    );
+  }
+
+  return context;
+}
+
+/**
+ * Triggers the `onAccept` function when an invite link is detected in the URL.
+ *
+ * @param invitedObjectSchema - The invited object schema.
+ * @param onAccept - Function to call when the invite is accepted.
+ * @param forValueHint - Hint for the value.
+ * @returns The accept invite hook.
+ */
+export class InviteListener<V extends CoValueOrZodSchema> {
+  constructor({
+    invitedObjectSchema,
+    onAccept,
+    forValueHint,
+  }: {
+    invitedObjectSchema: V;
+    onAccept: (projectID: ID<V>) => void;
+    forValueHint?: string;
+  }) {
+    // TODO Listen to the hashchange event
+    const _onAccept = onAccept;
+
+    // Subscribe to the onAccept function.
+    $effect(() => {
+      const ctx = getJazzContext<InstanceOfSchema<AccountClass<Account>>>();
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      _onAccept;
+      // Subscribe to the onAccept function.
+      untrack(() => {
+        // If there is no context, return.
+        if (!ctx.current) return;
+        if (!("me" in ctx.current)) return;
+
+        // Consume the invite link from the window location.
+        const result = consumeInviteLinkFromWindowLocation({
+          as: ctx.current.me,
+          invitedObjectSchema,
+          forValueHint,
+        });
+        // If the result is valid, call the onAccept function.
+        result
+          .then((result) => result && _onAccept(result?.valueID))
+          .catch((e) => {
+            console.error("Failed to accept invite", e);
+          });
+      });
+    });
+  }
+}

package/src/svelte/testing.ts

@@ -0,0 +1,42 @@
+import { Account, AnonymousJazzAgent, AuthSecretStorage } from "jazz-tools";
+import { TestJazzContextManager } from "jazz-tools/testing";
+import { JAZZ_AUTH_CTX, JAZZ_CTX, type JazzContext } from "./jazz.svelte.js";
+
+export function createJazzTestContext<Acc extends Account>(
+  opts: {
+    account?: Acc | { guest: AnonymousJazzAgent };
+    isAuthenticated?: boolean;
+  } = {},
+) {
+  const ctx = new Map<
+    typeof JAZZ_CTX | typeof JAZZ_AUTH_CTX,
+    JazzContext<Acc> | AuthSecretStorage
+  >();
+  const account = opts.account ?? (Account.getMe() as Acc);
+
+  const value = TestJazzContextManager.fromAccountOrGuest<Acc>(account, {
+    isAuthenticated: opts.isAuthenticated,
+  });
+
+  ctx.set(JAZZ_AUTH_CTX, value.getAuthSecretStorage());
+
+  if ("guest" in account) {
+    ctx.set(JAZZ_CTX, {
+      current: value.getCurrentValue(),
+    });
+  } else {
+    ctx.set(JAZZ_CTX, {
+      current: value.getCurrentValue(),
+    });
+  }
+
+  return ctx;
+}
+
+export {
+  createJazzTestAccount,
+  createJazzTestGuest,
+  linkAccounts,
+  setActiveAccount,
+  setupJazzTestSync,
+} from "jazz-tools/testing";

package/src/testing.ts

@@ -1,312 +1 @@
-import { AgentSecret, CryptoProvider, LocalNode, Peer } from "cojson";
-import { cojsonInternals } from "cojson";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
-import {
-  Account,
-  AccountClass,
-  type AnonymousJazzAgent,
-  AnyAccountSchema,
-  AuthCredentials,
-  type CoValueClass,
-  CoValueFromRaw,
-  InstanceOfSchema,
-  JazzContextManager,
-  JazzContextManagerAuthProps,
-  JazzContextManagerBaseProps,
-  activeAccountContext,
-  anySchemaToCoSchema,
-  createAnonymousJazzContext,
-  createJazzContext,
-  randomSessionProvider,
-} from "./internal.js";
-
-const syncServer: { current: LocalNode | null } = { current: null };
-
-type TestAccountSchema<Acc extends Account> = CoValueClass<Acc> & {
-  fromNode: (typeof Account)["fromNode"];
-  create: (options: {
-    creationProps: { name: string };
-    initialAgentSecret?: AgentSecret;
-    peersToLoadFrom?: Peer[];
-    crypto: CryptoProvider;
-  }) => Promise<Acc>;
-};
-
-export class TestJSCrypto extends PureJSCrypto {
-  static async create() {
-    if ("navigator" in globalThis && navigator.userAgent?.includes("jsdom")) {
-      // Mocking crypto seal & encrypt to make it work with JSDom. Getting "Error: Uint8Array expected" there
-      const crypto = new PureJSCrypto();
-
-      crypto.seal = (options) =>
-        `sealed_U${cojsonInternals.stableStringify(options.message)}` as any;
-      crypto.unseal = (sealed) =>
-        JSON.parse(sealed.substring("sealed_U".length));
-      crypto.encrypt = (message) =>
-        `encrypted_U${cojsonInternals.stableStringify(message)}` as any;
-      crypto.decryptRaw = (encrypted) =>
-        encrypted.substring("encrypted_U".length) as any;
-
-      return crypto;
-    }
-
-    // For non-jsdom environments, we use the real crypto
-    return new PureJSCrypto();
-  }
-}
-
-export function getPeerConnectedToTestSyncServer() {
-  if (!syncServer.current) {
-    throw new Error("Sync server not initialized");
-  }
-
-  const [aPeer, bPeer] = cojsonInternals.connectedPeers(
-    Math.random().toString(),
-    Math.random().toString(),
-    {
-      peer1role: "server",
-      peer2role: "server",
-    },
-  );
-  syncServer.current.syncManager.addPeer(aPeer);
-
-  return bPeer;
-}
-
-const SecretSeedMap = new Map<string, Uint8Array>();
-let isMigrationActive = false;
-
-export async function createJazzTestAccount<
-  S extends
-    | (AccountClass<Account> & CoValueFromRaw<Account>)
-    | AnyAccountSchema,
->(options?: {
-  isCurrentActiveAccount?: boolean;
-  AccountSchema?: S;
-  creationProps?: Record<string, unknown>;
-}): Promise<InstanceOfSchema<S>> {
-  const AccountClass = options?.AccountSchema
-    ? anySchemaToCoSchema(options.AccountSchema)
-    : Account;
-  const peers = [];
-  if (syncServer.current) {
-    peers.push(getPeerConnectedToTestSyncServer());
-  }
-
-  const crypto = await TestJSCrypto.create();
-  const secretSeed = crypto.newRandomSecretSeed();
-
-  const { node } = await LocalNode.withNewlyCreatedAccount({
-    creationProps: {
-      name: "Test Account",
-      ...options?.creationProps,
-    },
-    initialAgentSecret: crypto.agentSecretFromSecretSeed(secretSeed),
-    crypto,
-    peersToLoadFrom: peers,
-    migration: async (rawAccount, _node, creationProps) => {
-      if (isMigrationActive) {
-        throw new Error(
-          "It is not possible to create multiple accounts in parallel inside the test environment.",
-        );
-      }
-
-      isMigrationActive = true;
-
-      // @ts-expect-error - AccountClass doesn't infer the fromRaw static method
-      const account = AccountClass.fromRaw(rawAccount) as InstanceOfSchema<S>;
-
-      // We need to set the account as current because the migration
-      // will probably rely on the global me
-      const prevActiveAccount = activeAccountContext.maybeGet();
-      activeAccountContext.set(account);
-
-      await account.applyMigration?.(creationProps);
-
-      if (!options?.isCurrentActiveAccount) {
-        activeAccountContext.set(prevActiveAccount);
-      }
-
-      isMigrationActive = false;
-    },
-  });
-
-  const account = AccountClass.fromNode(node);
-  SecretSeedMap.set(account.id, secretSeed);
-
-  if (options?.isCurrentActiveAccount) {
-    activeAccountContext.set(account);
-  }
-
-  return account as InstanceOfSchema<S>;
-}
-
-export function setActiveAccount(account: Account) {
-  activeAccountContext.set(account);
-}
-
-export async function createJazzTestGuest() {
-  const ctx = await createAnonymousJazzContext({
-    crypto: await PureJSCrypto.create(),
-    peersToLoadFrom: [],
-  });
-
-  return {
-    guest: ctx.agent,
-  };
-}
-
-export type TestJazzContextManagerProps<Acc extends Account> =
-  JazzContextManagerBaseProps<Acc> & {
-    defaultProfileName?: string;
-    AccountSchema?: AccountClass<Acc> & CoValueFromRaw<Acc>;
-    isAuthenticated?: boolean;
-  };
-
-export class TestJazzContextManager<
-  Acc extends Account,
-> extends JazzContextManager<Acc, TestJazzContextManagerProps<Acc>> {
-  static fromAccountOrGuest<Acc extends Account>(
-    account?: Acc | { guest: AnonymousJazzAgent },
-    props?: TestJazzContextManagerProps<Acc>,
-  ) {
-    if (account && "guest" in account) {
-      return this.fromGuest<Acc>(account, props);
-    }
-
-    return this.fromAccount<Acc>(account ?? (Account.getMe() as Acc), props);
-  }
-
-  static fromAccount<Acc extends Account>(
-    account: Acc,
-    props?: TestJazzContextManagerProps<Acc>,
-  ) {
-    const context = new TestJazzContextManager<Acc>();
-
-    const provider = props?.isAuthenticated ? "testProvider" : "anonymous";
-    const storage = context.getAuthSecretStorage();
-    const node = account._raw.core.node;
-
-    const credentials = {
-      accountID: account.id,
-      accountSecret: node.getCurrentAgent().agentSecret,
-      secretSeed: SecretSeedMap.get(account.id),
-      provider,
-    } satisfies AuthCredentials;
-
-    storage.set(credentials);
-
-    context.updateContext(
-      {
-        AccountSchema: account.constructor as AccountClass<Acc> &
-          CoValueFromRaw<Acc>,
-        ...props,
-      },
-      {
-        me: account,
-        node,
-        done: () => {
-          node.gracefulShutdown();
-        },
-        logOut: async () => {
-          await storage.clear();
-          node.gracefulShutdown();
-        },
-      },
-      {
-        credentials,
-      },
-    );
-
-    return context;
-  }
-
-  static fromGuest<Acc extends Account>(
-    { guest }: { guest: AnonymousJazzAgent },
-    props: TestJazzContextManagerProps<Acc> = {},
-  ) {
-    const context = new TestJazzContextManager<Acc>();
-    const node = guest.node;
-
-    context.updateContext(props, {
-      guest,
-      node,
-      done: () => {
-        node.gracefulShutdown();
-      },
-      logOut: async () => {
-        node.gracefulShutdown();
-      },
-    });
-
-    return context;
-  }
-
-  async getNewContext(
-    props: TestJazzContextManagerProps<Acc>,
-    authProps?: JazzContextManagerAuthProps,
-  ) {
-    if (!syncServer.current) {
-      throw new Error(
-        "You need to setup a test sync server with setupJazzTestSync to use the Auth functions",
-      );
-    }
-
-    const context = await createJazzContext({
-      credentials: authProps?.credentials,
-      defaultProfileName: props.defaultProfileName,
-      newAccountProps: authProps?.newAccountProps,
-      peersToLoadFrom: [getPeerConnectedToTestSyncServer()],
-      crypto: await TestJSCrypto.create(),
-      sessionProvider: randomSessionProvider,
-      authSecretStorage: this.getAuthSecretStorage(),
-      AccountSchema: props.AccountSchema,
-    });
-
-    return {
-      me: context.account,
-      node: context.node,
-      done: () => {
-        context.done();
-      },
-      logOut: () => {
-        return context.logOut();
-      },
-    };
-  }
-}
-
-export async function linkAccounts(
-  a: Account,
-  b: Account,
-  aRole: "server" | "client" = "server",
-  bRole: "server" | "client" = "server",
-) {
-  const [aPeer, bPeer] = cojsonInternals.connectedPeers(b.id, a.id, {
-    peer1role: aRole,
-    peer2role: bRole,
-  });
-
-  a._raw.core.node.syncManager.addPeer(aPeer);
-  b._raw.core.node.syncManager.addPeer(bPeer);
-
-  await a.waitForAllCoValuesSync();
-  await b.waitForAllCoValuesSync();
-}
-
-export async function setupJazzTestSync() {
-  if (syncServer.current) {
-    syncServer.current.gracefulShutdown();
-  }
-
-  const account = await Account.create({
-    creationProps: {
-      name: "Test Account",
-    },
-    crypto: await TestJSCrypto.create(),
-  });
-
-  syncServer.current = account._raw.core.node;
-
-  return account;
-}
+export * from "./tools/testing.js";

package/src/tiptap/index.ts

@@ -0,0 +1,28 @@
+import { Extension } from "@tiptap/core";
+import { CoRichText } from "jazz-tools";
+import { createJazzPlugin } from "jazz-tools/prosemirror";
+
+export interface JazzSyncOptions {
+  /** The CoRichText instance to synchronize with */
+  coRichText: CoRichText;
+  /** Configuration options for the plugin */
+  config?: Parameters<typeof createJazzPlugin>[1];
+}
+
+export const JazzSyncExtension = Extension.create<JazzSyncOptions>({
+  name: "jazzSync",
+
+  addOptions() {
+    return {
+      coRichText: undefined as any,
+      config: {},
+    };
+  },
+
+  addProseMirrorPlugins() {
+    if (!this.options.coRichText) {
+      throw new Error("JazzSyncExtension requires a CoRichText value");
+    }
+    return [createJazzPlugin(this.options.coRichText, this.options.config)];
+  },
+});

package/src/tools/auth/KvStoreContext.ts

@@ -0,0 +1,39 @@
+export interface KvStore {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  delete(key: string): Promise<void>;
+  clearAll(): Promise<void>;
+}
+
+export class KvStoreContext {
+  private static instance: KvStoreContext;
+  private storageInstance: KvStore | null = null;
+
+  private constructor() {}
+
+  public static getInstance(): KvStoreContext {
+    if (!KvStoreContext.instance) {
+      KvStoreContext.instance = new KvStoreContext();
+    }
+    return KvStoreContext.instance;
+  }
+
+  public isInitialized(): boolean {
+    return this.storageInstance !== null;
+  }
+
+  public initialize(store: KvStore): void {
+    if (!this.storageInstance) {
+      this.storageInstance = store;
+    }
+  }
+
+  public getStorage(): KvStore {
+    if (!this.storageInstance) {
+      throw new Error("Storage instance is not initialized.");
+    }
+    return this.storageInstance;
+  }
+}
+
+export default KvStoreContext;

package/src/tools/auth/clerk/getClerkUsername.ts

@@ -0,0 +1,36 @@
+import type { MinimalClerkClient } from "./types.js";
+
+export function getClerkUsername(
+  clerkClient: Pick<MinimalClerkClient, "user">,
+) {
+  if (!clerkClient.user) {
+    return null;
+  }
+
+  if (clerkClient.user.fullName) {
+    return clerkClient.user.fullName;
+  }
+
+  if (clerkClient.user.firstName) {
+    if (clerkClient.user.lastName) {
+      return `${clerkClient.user.firstName} ${clerkClient.user.lastName}`;
+    }
+
+    return clerkClient.user.firstName;
+  }
+
+  if (clerkClient.user.username) {
+    return clerkClient.user.username;
+  }
+
+  if (clerkClient.user.primaryEmailAddress?.emailAddress) {
+    const emailUsername =
+      clerkClient.user.primaryEmailAddress.emailAddress.split("@")[0];
+
+    if (emailUsername) {
+      return emailUsername;
+    }
+  }
+
+  return clerkClient.user.id;
+}