jazz-tools 0.17.14 → 0.18.1

package/src/better-auth/auth/tests/client.test.ts

@@ -0,0 +1,249 @@
+import { createAuthClient } from "better-auth/client";
+import type { Account, AuthSecretStorage } from "jazz-tools";
+import {
+  TestJazzContextManager,
+  setActiveAccount,
+  setupJazzTestSync,
+} from "jazz-tools/testing";
+import { assert, beforeEach, describe, expect, it, vi } from "vitest";
+import { jazzPluginClient } from "../client.js";
+
+describe("auth client", () => {
+  let account: Account;
+  let jazzContextManager: TestJazzContextManager<Account>;
+  let authSecretStorage: AuthSecretStorage;
+  let authClient: ReturnType<
+    typeof createAuthClient<{
+      plugins: ReturnType<typeof jazzPluginClient>[];
+    }>
+  >;
+  let customFetchImpl = vi.fn();
+
+  beforeEach(async () => {
+    account = await setupJazzTestSync();
+    setActiveAccount(account);
+
+    jazzContextManager = TestJazzContextManager.fromAccountOrGuest(account);
+    authSecretStorage = jazzContextManager.getAuthSecretStorage();
+
+    // start a new context
+    await jazzContextManager.createContext({});
+
+    authClient = createAuthClient({
+      baseURL: "http://localhost:3000",
+      plugins: [jazzPluginClient()],
+      fetchOptions: {
+        customFetchImpl,
+      },
+    });
+
+    const context = jazzContextManager.getCurrentValue();
+    assert(context, "Jazz context is not available");
+    authClient.jazz.setJazzContext(context);
+    authClient.jazz.setAuthSecretStorage(authSecretStorage);
+
+    customFetchImpl.mockReset();
+  });
+
+  it("should send Jazz credentials over signup", async () => {
+    const credentials = await authSecretStorage.get();
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+    assert(credentials, "Jazz credentials are not available");
+
+    customFetchImpl.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          token: "6diDScDDcLJLl3sxAEestZz63mrw9Azy",
+          user: {
+            id: "S6SDKApdnh746gUnP3zujzsEY53tjuTm",
+            email: "test@jazz.dev",
+            name: "Matteo",
+            image: null,
+            emailVerified: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+          jazzAuth: {
+            accountID: credentials.accountID,
+            secretSeed: credentials.secretSeed,
+            accountSecret: credentials.accountSecret,
+          },
+        }),
+      ),
+    );
+
+    // Sign up
+    await authClient.signUp.email({
+      email: "test@jazz.dev",
+      password: "12345678",
+      name: "Matteo",
+    });
+
+    expect(customFetchImpl).toHaveBeenCalledTimes(1);
+    expect(customFetchImpl.mock.calls[0]![0].toString()).toBe(
+      "http://localhost:3000/api/auth/sign-up/email",
+    );
+
+    // Verify the credentials have been injected in the request body
+    expect(
+      customFetchImpl.mock.calls[0]![1].headers.get("x-jazz-auth")!,
+    ).toEqual(
+      JSON.stringify({
+        accountID: credentials!.accountID,
+        secretSeed: credentials!.secretSeed,
+        accountSecret: credentials!.accountSecret,
+      }),
+    );
+
+    expect(authSecretStorage.isAuthenticated).toBe(true);
+
+    // Verify the profile name has been updated
+    const context = jazzContextManager.getCurrentValue();
+    assert(context && "me" in context);
+    expect(context.me.$jazz.id).toBe(credentials!.accountID);
+  });
+
+  it("should become logged in Jazz credentials after sign-in", async () => {
+    const credentials = await jazzContextManager.getAuthSecretStorage().get();
+
+    // Log out from initial context
+    await jazzContextManager.logOut();
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+
+    customFetchImpl.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          user: {
+            id: "123",
+            email: "test@jazz.dev",
+            name: "Matteo",
+          },
+          jazzAuth: {
+            accountID: credentials!.accountID,
+            secretSeed: credentials!.secretSeed,
+            accountSecret: credentials!.accountSecret,
+            provider: "better-auth",
+          },
+        }),
+      ),
+    );
+
+    // Retrieve the BetterAuth session and trigger the authentication
+    await authClient.signIn.email({
+      email: "test@jazz.dev",
+      password: "12345678",
+    });
+
+    expect(customFetchImpl).toHaveBeenCalledTimes(1);
+    expect(customFetchImpl.mock.calls[0]![0].toString()).toBe(
+      "http://localhost:3000/api/auth/sign-in/email",
+    );
+
+    expect(authSecretStorage.isAuthenticated).toBe(true);
+
+    const newContext = jazzContextManager.getCurrentValue()!;
+    expect("me" in newContext).toBe(true);
+    expect(await authSecretStorage.get()).toMatchObject({
+      accountID: credentials!.accountID,
+      provider: "better-auth",
+    });
+  });
+
+  it("should logout from Jazz after BetterAuth sign-out", async () => {
+    const credentials = await authSecretStorage.get();
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+    customFetchImpl.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          token: "6diDScDDcLJLl3sxAEestZz63mrw9Azy",
+          user: {
+            id: "S6SDKApdnh746gUnP3zujzsEY53tjuTm",
+            email: "test@jazz.dev",
+            name: "Matteo",
+            image: null,
+            emailVerified: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+          jazzAuth: {
+            accountID: credentials!.accountID,
+            secretSeed: credentials!.secretSeed,
+            accountSecret: credentials!.accountSecret,
+            provider: "better-auth",
+          },
+        }),
+      ),
+    );
+
+    // 1. Sign up
+    await authClient.signUp.email({
+      email: "test@jazz.dev",
+      password: "12345678",
+      name: "Matteo",
+    });
+
+    expect(authSecretStorage.isAuthenticated).toBe(true);
+
+    // 2. Sign out
+    customFetchImpl.mockResolvedValueOnce(
+      new Response(JSON.stringify({ success: true })),
+    );
+
+    await authClient.signOut();
+
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+
+    const anonymousCredentials = await authSecretStorage.get();
+    expect(anonymousCredentials).not.toMatchObject(credentials!);
+  });
+
+  it("should logout from Jazz after BetterAuth user deletion", async () => {
+    const credentials = await authSecretStorage.get();
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+    customFetchImpl.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          token: "6diDScDDcLJLl3sxAEestZz63mrw9Azy",
+          user: {
+            id: "S6SDKApdnh746gUnP3zujzsEY53tjuTm",
+            email: "test@jazz.dev",
+            name: "Matteo",
+            image: null,
+            emailVerified: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+          jazzAuth: {
+            accountID: credentials!.accountID,
+            secretSeed: credentials!.secretSeed,
+            accountSecret: credentials!.accountSecret,
+            provider: "better-auth",
+          },
+        }),
+      ),
+    );
+
+    // 1. Sign up
+    await authClient.signUp.email({
+      email: "test@jazz.dev",
+      password: "12345678",
+      name: "Matteo",
+    });
+
+    expect(authSecretStorage.isAuthenticated).toBe(true);
+
+    // 2. Delete user
+    customFetchImpl.mockResolvedValueOnce(
+      new Response(JSON.stringify({ success: true })),
+    );
+
+    await authClient.deleteUser();
+
+    expect(authSecretStorage.isAuthenticated).toBe(false);
+
+    const anonymousCredentials = await authSecretStorage.get();
+    expect(anonymousCredentials).not.toMatchObject(credentials!);
+  });
+
+  it.todo("should logout from Better Auth after Jazz's log-out");
+});

package/src/better-auth/auth/tests/server.test.ts

@@ -0,0 +1,226 @@
+import { betterAuth } from "better-auth";
+import { memoryAdapter } from "better-auth/adapters/memory";
+import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+import { jazzPlugin } from "../server.js";
+
+describe("Better Auth - Signup and Login Tests", () => {
+  let auth: ReturnType<typeof betterAuth>;
+  let accountCreationSpy: Mock;
+  let verificationCreationSpy: Mock;
+
+  beforeEach(() => {
+    accountCreationSpy = vi.fn();
+    verificationCreationSpy = vi.fn();
+
+    // Create auth instance with in-memory database
+    auth = betterAuth({
+      database: memoryAdapter({
+        user: [],
+        session: [],
+        verification: [],
+        account: [],
+      }),
+      plugins: [jazzPlugin()],
+      emailAndPassword: {
+        enabled: true,
+        requireEmailVerification: false, // Disable for testing
+      },
+      socialProviders: {
+        github: {
+          clientId: "123",
+          clientSecret: "123",
+        },
+      },
+      databaseHooks: {
+        user: {
+          create: {
+            after: accountCreationSpy,
+          },
+        },
+        verification: {
+          create: {
+            after: verificationCreationSpy,
+          },
+        },
+      },
+      session: {
+        expiresIn: 60 * 60 * 24 * 7, // 7 days
+      },
+    });
+  });
+
+  describe("User Registration (Signup)", () => {
+    it("should successfully register a new user with email and password", async () => {
+      const userData = {
+        name: "test",
+        email: "test@example.com",
+        password: "securePassword123",
+      };
+
+      const jazzAuth = {
+        accountID: "123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "123",
+        provider: "better-auth",
+      };
+
+      const result = await auth.api.signUpEmail({
+        body: userData,
+        headers: {
+          "x-jazz-auth": JSON.stringify(jazzAuth),
+        },
+      });
+
+      expect(result).toBeDefined();
+      expect(result).toMatchObject({
+        user: {
+          id: expect.any(String),
+          email: userData.email,
+          name: userData.name,
+          image: undefined,
+          emailVerified: false,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        },
+        jazzAuth: jazzAuth,
+      });
+
+      const res = await (await auth.$context).adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: result.user.id,
+          },
+        ],
+      });
+
+      expect(res).toMatchObject({
+        id: result.user.id,
+        accountID: "123",
+        encryptedCredentials: expect.any(String),
+      });
+    });
+
+    it("should fail to register user without account ID", async () => {
+      const userData = {
+        name: "test",
+        email: "email@email.it",
+        password: "securePassword123",
+      };
+
+      await expect(
+        auth.api.signUpEmail({
+          body: userData,
+        }),
+      ).rejects.toThrow("JazzAuth is required");
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("should have AccountID in the registration hook", async () => {
+      const userData = {
+        name: "test",
+        email: "email@email.it",
+        password: "securePassword123",
+      };
+
+      const jazzAuth = {
+        accountID: "123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "123",
+        provider: "better-auth",
+      };
+
+      await auth.api.signUpEmail({
+        body: userData,
+        headers: {
+          "x-jazz-auth": JSON.stringify(jazzAuth),
+        },
+      });
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(1);
+      expect(accountCreationSpy).toHaveBeenCalledWith(
+        // user
+        expect.objectContaining({ accountID: "123" }),
+        // context
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("User login (Signin)", () => {
+    it("should successfully login a new user with email and password", async () => {
+      const userData = {
+        name: "test",
+        email: "test@example.com",
+        password: "securePassword123",
+      };
+
+      const jazzAuth = {
+        accountID: "123",
+        secretSeed: [1, 2, 3],
+        accountSecret: "123",
+        provider: "better-auth",
+      };
+
+      await auth.api.signUpEmail({
+        body: userData,
+        headers: {
+          "x-jazz-auth": JSON.stringify(jazzAuth),
+        },
+      });
+
+      const result = await auth.api.signInEmail({
+        body: {
+          email: userData.email,
+          password: userData.password,
+        },
+      });
+
+      expect(result).toBeDefined();
+      expect(result).toMatchObject({
+        user: {
+          id: expect.any(String),
+          email: userData.email,
+          name: userData.name,
+          image: undefined,
+          emailVerified: false,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        },
+        jazzAuth: jazzAuth,
+      });
+    });
+  });
+
+  describe("Social Login", () => {
+    it("should store jazzAuth in verification table when using social provider", async () => {
+      await auth.api.signInSocial({
+        body: {
+          provider: "github",
+          callbackURL: "http://localhost:3000/api/auth/sign-in/social/callback",
+        },
+        headers: {
+          "x-jazz-auth": JSON.stringify({
+            accountID: "123",
+            secretSeed: [1, 2, 3],
+            accountSecret: "123",
+          }),
+        },
+      });
+
+      expect(verificationCreationSpy).toHaveBeenCalledTimes(1);
+      expect(verificationCreationSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          value: expect.stringContaining('"accountID":"123"'),
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it.todo(
+      "should create a new account with jazz auth when using social provider",
+    );
+  });
+});

package/src/browser/auth/PasskeyAuth.ts

@@ -82,14 +82,14 @@ export class BrowserPasskeyAuth {
       username,
     });
 
-    const currentAccount = await Account.getMe().ensureLoaded({
+    const currentAccount = await Account.getMe().$jazz.ensureLoaded({
       resolve: {
         profile: true,
       },
     });
 
     if (username.trim().length !== 0) {
-      currentAccount.profile.name = username;
+      currentAccount.profile.$jazz.set("name", username);
     }
 
     await this.authSecretStorage.set({

package/src/browser/createBrowserContext.ts

@@ -272,7 +272,7 @@ export function createInviteLink<C extends CoValue>(
     valueHint,
   }: { baseURL?: string; valueHint?: string } = {},
 ): string {
-  const coValueCore = value._raw.core;
+  const coValueCore = value.$jazz.raw.core;
   let currentCoValue = coValueCore;
 
   while (currentCoValue.verified.header.ruleset.type === "ownedByGroup") {
@@ -289,7 +289,7 @@ export function createInviteLink<C extends CoValue>(
   const inviteSecret = group.createInvite(role);
 
   return `${baseURL}#/invite/${valueHint ? valueHint + "/" : ""}${
-    value.id
+    value.$jazz.id
   }/${inviteSecret}`;
 }
 

package/src/browser/tests/PasskeyAuth.test.ts

@@ -198,7 +198,7 @@ describe("BrowserPasskeyAuth", () => {
 
       await auth.signUp("");
 
-      const currentAccount = await Account.getMe().ensureLoaded({
+      const currentAccount = await Account.getMe().$jazz.ensureLoaded({
         resolve: {
           profile: true,
         },
@@ -230,7 +230,7 @@ describe("BrowserPasskeyAuth", () => {
 
       await auth.signUp("testuser");
 
-      const currentAccount = await Account.getMe().ensureLoaded({
+      const currentAccount = await Account.getMe().$jazz.ensureLoaded({
         resolve: {
           profile: true,
         },

package/src/inspector/custom-element.tsx

@@ -53,8 +53,8 @@ export class JazzInspectorElement extends HTMLElement {
 
     this.root?.render(
       <JazzInspectorInternal
-        localNode={this.account._raw.core.node}
-        accountId={this.account._raw.id}
+        localNode={this.account.$jazz.localNode}
+        accountId={this.account.$jazz.raw.id}
       />,
     );
   }

package/src/inspector/viewer/new-app.tsx

@@ -72,7 +72,7 @@ export function JazzInspector({ position = "right" }: { position?: Position }) {
     <JazzInspectorInternal
       position={position}
       localNode={localNode}
-      accountId={me?._raw.id}
+      accountId={me?.$jazz.raw.id}
     />
   );
 }

package/src/media/create-image.test.ts

@@ -10,7 +10,7 @@ describe("createImage", async () => {
   const getPlaceholderBase64 = vi.fn();
   const createFileStreamFromSource = vi
     .fn()
-    .mockResolvedValue(FileStream.create({ owner: account._owner }));
+    .mockResolvedValue(FileStream.create({ owner: account }));
   const resize = vi.fn();
 
   const createImage = createImageFactory({
@@ -33,7 +33,7 @@ describe("createImage", async () => {
     getImageSize.mockResolvedValue({ width: 1, height: 1 });
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       placeholder: false,
       progressive: false,
     });
@@ -60,7 +60,7 @@ describe("createImage", async () => {
     );
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       placeholder: "blur",
       progressive: false,
     });
@@ -83,7 +83,7 @@ describe("createImage", async () => {
     resize.mockResolvedValue(new Blob([White1920], { type: "image/png" }));
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       placeholder: false,
       progressive: false,
       maxSize: 256,
@@ -109,7 +109,7 @@ describe("createImage", async () => {
     getImageSize.mockResolvedValue({ width: 1, height: 1 });
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       placeholder: false,
       progressive: false,
       maxSize: 256,
@@ -136,7 +136,7 @@ describe("createImage", async () => {
     resize.mockResolvedValue(new Blob([White1920], { type: "image/png" }));
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       progressive: true,
       placeholder: false,
     });
@@ -164,7 +164,7 @@ describe("createImage", async () => {
     resize.mockResolvedValue(new Blob([White1920], { type: "image/png" }));
 
     const image = await createImage(imageBlob, {
-      owner: account._owner,
+      owner: account,
       maxSize: 256,
       placeholder: false,
       progressive: true,

package/src/media/create-image.ts

@@ -137,7 +137,7 @@ async function createImage(
    * On the client side, the image will be loaded progressively, starting from the smallest size and increasing the size until the original size is reached.
    */
   if (options?.progressive) {
-    imageCoValue.progressive = true;
+    imageCoValue.$jazz.set("progressive", true);
 
     const resizes = ([256, 1024, 2048] as const).filter(
       (s) =>
@@ -153,8 +153,10 @@ async function createImage(
       );
 
       const blob = await impl.resize(imageBlobOrFile, width, height);
-      imageCoValue[`${width}x${height}`] =
-        await impl.createFileStreamFromSource(blob, options?.owner);
+      imageCoValue.$jazz.set(
+        `${width}x${height}`,
+        await impl.createFileStreamFromSource(blob, options?.owner),
+      );
     }
   }
 

package/src/media/index.ts

@@ -27,7 +27,7 @@ export { createImageFactory };
  *     // Creates ImageDefinition with a blurry placeholder, limited to 1024px
  *     // on the longest side, and multiple resolutions automatically
  *     const image = await createImage(file, {
- *       owner: me._owner,
+ *       owner: me.$jazz.owner,
  *       maxSize: 1024,
  *       placeholder: "blur",
  *       progressive: true,