jazz-tools 0.14.27 → 0.15.0

package/src/tools/exports.ts

@@ -0,0 +1,117 @@
+export type {
+  AgentID,
+  CoValueUniqueness,
+  CryptoProvider,
+  InviteSecret,
+  Peer,
+  SessionID,
+  SyncMessage,
+} from "cojson";
+
+export * as z from "./implementation/zodSchema/zodReExport.js";
+
+export type { CoValue, ID } from "./internal.js";
+
+export { Encoders, coField } from "./internal.js";
+
+export { Inbox, InboxSender } from "./internal.js";
+
+export { Group } from "./internal.js";
+export { CoValueBase } from "./internal.js";
+export { Profile } from "./internal.js";
+export { SchemaUnion } from "./internal.js";
+
+export { co } from "./internal.js";
+
+export type {
+  CoValueClass,
+  CoValueFromRaw,
+  DeeplyLoaded,
+  Resolved,
+  RefsToResolve,
+  RefsToResolveStrict,
+  CoMapInit,
+  CoFeedEntry,
+  TextPos,
+  AccountClass,
+  AccountCreationProps,
+} from "./internal.js";
+
+export {
+  CoMap,
+  CoList,
+  BinaryCoStream,
+  CoFeed,
+  CoStream,
+  FileStream,
+  CoPlainText,
+  CoRichText,
+  Account,
+  isControlledAccount,
+  createCoValueObservable,
+  loadCoValue,
+  subscribeToCoValue,
+  ImageDefinition,
+  SubscriptionScope,
+} from "./internal.js";
+
+export {
+  JazzContextManager,
+  type JazzContextManagerAuthProps,
+} from "./internal.js";
+
+export {
+  AuthSecretStorage,
+  type AuthSetPayload,
+} from "./auth/AuthSecretStorage.js";
+export {
+  JazzClerkAuth,
+  MinimalClerkClient,
+  isClerkCredentials,
+  BrowserClerkAuth,
+} from "./auth/clerk/index.js";
+export { KvStoreContext, type KvStore } from "./auth/KvStoreContext.js";
+export { InMemoryKVStore } from "./auth/InMemoryKVStore.js";
+export { DemoAuth } from "./auth/DemoAuth.js";
+export { PassphraseAuth } from "./auth/PassphraseAuth.js";
+
+export {
+  createInviteLink,
+  parseInviteLink,
+  consumeInviteLink,
+} from "./implementation/invites.js";
+
+export {
+  AnonymousJazzAgent,
+  createAnonymousJazzContext,
+  createJazzContextFromExistingCredentials,
+  createJazzContextForNewAccount,
+  createJazzContext,
+  randomSessionProvider,
+  type AuthResult,
+  type Credentials,
+  type JazzContextWithAccount,
+} from "./internal.js";
+
+export type * from "./types.js";
+
+export {
+  zodSchemaToCoSchema,
+  anySchemaToCoSchema,
+  type InstanceOfSchema,
+  type InstanceOfSchemaCoValuesNullable,
+  type CoValueOrZodSchema,
+  type Loaded,
+  type AccountSchema,
+  type AnyAccountSchema,
+  type CoListSchema,
+  type CoMapSchema,
+  type CoFeedSchema,
+  type PlainTextSchema,
+  type FileStreamSchema,
+  type ResolveQuery,
+  type ResolveQueryStrict,
+  type InitFor,
+  type CoRecordSchema,
+  type CoProfileSchema,
+} from "./internal.js";

package/src/tools/index.ts

@@ -0,0 +1,8 @@
+export * from "./exports.js";
+
+export {
+  MAX_RECOMMENDED_TX_SIZE,
+  cojsonInternals,
+  logger,
+  LogLevel,
+} from "cojson";

package/src/tools/testing.ts

@@ -0,0 +1,301 @@
+import { LocalNode } from "cojson";
+import { cojsonInternals } from "cojson";
+import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import {
+  Account,
+  AccountClass,
+  type AnonymousJazzAgent,
+  AnyAccountSchema,
+  AuthCredentials,
+  CoValueFromRaw,
+  InstanceOfSchema,
+  JazzContextManager,
+  JazzContextManagerAuthProps,
+  JazzContextManagerBaseProps,
+  activeAccountContext,
+  anySchemaToCoSchema,
+  createAnonymousJazzContext,
+  createJazzContext,
+  randomSessionProvider,
+} from "./internal.js";
+
+const syncServer: { current: LocalNode | null } = { current: null };
+
+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;
+}