jazz-tools 0.18.5 → 0.18.6

package/src/better-auth/auth/tests/react.test.tsx

@@ -0,0 +1,43 @@
+// @vitest-environment jsdom
+import { render } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { AuthProvider } from "../react";
+import { createAuthClient } from "better-auth/client";
+import { jazzPluginClient } from "../client";
+import { JazzReactProvider } from "jazz-tools/react";
+
+describe("AuthProvider", () => {
+  it("should throw if no JazzContext is set", () => {
+    const betterAuthClient = createAuthClient({
+      plugins: [jazzPluginClient()],
+    });
+
+    expect(() => {
+      render(
+        <AuthProvider betterAuthClient={betterAuthClient}>
+          <div />
+        </AuthProvider>,
+      );
+    }).toThrow(
+      "You need to set up a JazzProvider on top of your app to use this hook.",
+    );
+  });
+
+  it("should render with JazzReactProvider", () => {
+    const betterAuthClient = createAuthClient({
+      plugins: [jazzPluginClient()],
+    });
+
+    render(
+      <JazzReactProvider
+        // @ts-expect-error - no memory storage
+        storage={["memory"]}
+        sync={{ peer: "ws://", when: "never" }}
+      >
+        <AuthProvider betterAuthClient={betterAuthClient}>
+          <div />
+        </AuthProvider>
+      </JazzReactProvider>,
+    );
+  });
+});

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

@@ -12,100 +12,44 @@ import {
 } from "vitest";
 import { OAuth2Server } from "oauth2-mock-server";
 import { jazzPlugin } from "../server.js";
-import { genericOAuth } from "better-auth/plugins";
-
-describe("Better Auth - Signup and Login Tests", async () => {
-  const providerId = "test";
-  const clientId = "test-client-id";
-  const clientSecret = "test-client-secret";
-  const server = new OAuth2Server();
-  await server.start();
-  const oauthPort = Number(server.issuer.url?.split(":")[2]!);
-
-  let auth: ReturnType<
-    typeof betterAuth<{
-      plugins: ReturnType<typeof jazzPlugin | typeof genericOAuth>[];
-    }>
-  >;
-  let accountCreationSpy: Mock;
-  let verificationCreationSpy: Mock;
-
-  beforeAll(async () => {
-    await server.issuer.keys.generate("RS256");
-
-    server.service.on("beforeUserinfo", (userInfoResponse) => {
-      userInfoResponse.body = {
-        email: "oauth2@test.com",
-        name: "OAuth2 Test",
-        sub: "oauth2",
-        picture: "https://test.com/picture.png",
-        email_verified: true,
-      };
-      userInfoResponse.statusCode = 200;
-    });
-  });
-
-  afterAll(async () => {
-    await server.stop();
-  });
-
-  beforeEach(() => {
-    accountCreationSpy = vi.fn();
-    verificationCreationSpy = vi.fn();
-
-    // Create auth instance with in-memory database
-    auth = betterAuth({
-      database: memoryAdapter({
-        user: [],
-        session: [],
-        verification: [],
-        account: [],
-      }),
-      baseURL: "http://localhost:3000",
-      plugins: [
-        jazzPlugin(),
-        genericOAuth({
-          config: [
-            {
-              providerId,
-              discoveryUrl: `http://localhost:${oauthPort}/.well-known/openid-configuration`,
-              authorizationUrl: `http://localhost:${oauthPort}/authorize`,
-              clientId: clientId,
-              clientSecret: clientSecret,
-              pkce: true,
-            },
-          ],
+import { emailOTP, genericOAuth } from "better-auth/plugins";
+
+describe("Better-Auth server plugin", async () => {
+  describe("Email & Password", () => {
+    let auth: ReturnType<
+      typeof betterAuth<{
+        plugins: ReturnType<typeof jazzPlugin>[];
+      }>
+    >;
+
+    let accountCreationSpy: Mock;
+
+    beforeEach(() => {
+      accountCreationSpy = vi.fn();
+
+      // Create auth instance with in-memory database
+      auth = betterAuth({
+        database: memoryAdapter({
+          user: [],
+          session: [],
+          verification: [],
+          account: [],
         }),
-      ],
-      emailAndPassword: {
-        enabled: true,
-        requireEmailVerification: false, // Disable for testing
-      },
-      socialProviders: {
-        github: {
-          clientId: "123",
-          clientSecret: "123",
-        },
-      },
-      databaseHooks: {
-        user: {
-          create: {
-            after: accountCreationSpy,
-          },
+        plugins: [jazzPlugin()],
+        emailAndPassword: {
+          enabled: true,
+          requireEmailVerification: false, // Disable for testing
         },
-        verification: {
-          create: {
-            after: verificationCreationSpy,
+        databaseHooks: {
+          user: {
+            create: {
+              after: accountCreationSpy,
+            },
           },
         },
-      },
-      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",
@@ -203,9 +147,7 @@ describe("Better Auth - Signup and Login Tests", async () => {
         expect.any(Object),
       );
     });
-  });
 
-  describe("User login (Signin)", () => {
     it("should successfully login a new user with email and password", async () => {
       const userData = {
         name: "test",
@@ -250,7 +192,90 @@ describe("Better Auth - Signup and Login Tests", async () => {
     });
   });
 
-  describe("Social Login", () => {
+  describe("OAuth/Social plugin", async () => {
+    const providerId = "test";
+    const clientId = "test-client-id";
+    const clientSecret = "test-client-secret";
+    const server = new OAuth2Server();
+    await server.start();
+    const oauthPort = Number(server.issuer.url?.split(":")[2]!);
+
+    let auth: ReturnType<
+      typeof betterAuth<{
+        plugins: ReturnType<typeof jazzPlugin | typeof genericOAuth>[];
+      }>
+    >;
+    let accountCreationSpy: Mock;
+    let verificationCreationSpy: Mock;
+
+    beforeAll(async () => {
+      await server.issuer.keys.generate("RS256");
+
+      server.service.on("beforeUserinfo", (userInfoResponse) => {
+        userInfoResponse.body = {
+          email: "oauth2@test.com",
+          name: "OAuth2 Test",
+          sub: "oauth2",
+          picture: "https://test.com/picture.png",
+          email_verified: true,
+        };
+        userInfoResponse.statusCode = 200;
+      });
+    });
+
+    afterAll(async () => {
+      await server.stop();
+    });
+
+    beforeEach(() => {
+      accountCreationSpy = vi.fn();
+      verificationCreationSpy = vi.fn();
+
+      // Create auth instance with in-memory database
+      auth = betterAuth({
+        database: memoryAdapter({
+          user: [],
+          session: [],
+          verification: [],
+          account: [],
+        }),
+        baseURL: "http://localhost:3000",
+        plugins: [
+          jazzPlugin(),
+          genericOAuth({
+            config: [
+              {
+                providerId,
+                discoveryUrl: `http://localhost:${oauthPort}/.well-known/openid-configuration`,
+                authorizationUrl: `http://localhost:${oauthPort}/authorize`,
+                clientId: clientId,
+                clientSecret: clientSecret,
+                pkce: true,
+              },
+            ],
+          }),
+        ],
+        socialProviders: {
+          github: {
+            clientId: "123",
+            clientSecret: "123",
+          },
+        },
+        databaseHooks: {
+          user: {
+            create: {
+              after: accountCreationSpy,
+            },
+          },
+          verification: {
+            create: {
+              after: verificationCreationSpy,
+            },
+          },
+        },
+      });
+    });
+
     it("should store jazzAuth in verification table when using social provider", async () => {
       await auth.api.signInSocial({
         body: {
@@ -266,13 +291,11 @@ describe("Better Auth - Signup and Login Tests", async () => {
         },
       });
 
-      expect(verificationCreationSpy).toHaveBeenCalledTimes(1);
-      expect(verificationCreationSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: expect.stringContaining('"accountID":"123"'),
-        }),
-        expect.any(Object),
-      );
+      expect(verificationCreationSpy).toHaveBeenCalledTimes(2);
+      expect(verificationCreationSpy.mock.calls[1]?.[0]).toMatchObject({
+        identifier: expect.stringMatching("-jazz-auth"),
+        value: expect.stringContaining('"accountID":"123"'),
+      });
     });
 
     it("should create a new account with jazz auth when using social provider", async () => {
@@ -311,4 +334,159 @@ describe("Better Auth - Signup and Login Tests", async () => {
       );
     });
   });
+
+  describe("Email OTP plugin", () => {
+    let auth: ReturnType<
+      typeof betterAuth<{
+        plugins: ReturnType<typeof jazzPlugin | typeof emailOTP>[];
+      }>
+    >;
+
+    let accountCreationSpy: Mock;
+    let verificationCreationSpy: Mock;
+    let sendVerificationOTPSpy: Mock;
+
+    beforeEach(() => {
+      accountCreationSpy = vi.fn();
+      verificationCreationSpy = vi.fn();
+      sendVerificationOTPSpy = vi.fn();
+      // Create auth instance with in-memory database
+      auth = betterAuth({
+        database: memoryAdapter({
+          user: [],
+          session: [],
+          verification: [],
+          account: [],
+        }),
+        plugins: [
+          jazzPlugin(),
+          emailOTP({
+            allowedAttempts: 5,
+            otpLength: 6,
+            expiresIn: 600,
+            sendVerificationOTP: sendVerificationOTPSpy,
+          }),
+        ],
+        emailAndPassword: {
+          enabled: true,
+          requireEmailVerification: false, // Disable for testing
+        },
+        databaseHooks: {
+          user: {
+            create: {
+              after: accountCreationSpy,
+            },
+          },
+          verification: {
+            create: {
+              after: verificationCreationSpy,
+            },
+          },
+        },
+      });
+    });
+
+    it("should create a new account with jazz auth when using email OTP", async () => {
+      let OTP: string = "";
+
+      sendVerificationOTPSpy.mockImplementationOnce(({ otp }) => {
+        OTP = otp;
+      });
+
+      await auth.api.sendVerificationOTP({
+        headers: {
+          "x-jazz-auth": JSON.stringify({
+            accountID: "123",
+            secretSeed: [1, 2, 3],
+            accountSecret: "123",
+          }),
+        },
+        body: {
+          email: "email@email.it",
+          type: "sign-in",
+        },
+      });
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(0);
+      expect(sendVerificationOTPSpy).toHaveBeenCalledTimes(1);
+      expect(verificationCreationSpy).toHaveBeenCalledTimes(2);
+      expect(verificationCreationSpy.mock.calls[0]?.[0]).toMatchObject(
+        expect.objectContaining({
+          identifier: "sign-in-otp-email@email.it-jazz-auth",
+          value: expect.stringContaining('"accountID":"123"'),
+        }),
+      );
+
+      await auth.api.signInEmailOTP({
+        body: {
+          email: "email@email.it",
+          otp: OTP,
+        },
+      });
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(1);
+      expect(accountCreationSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ accountID: "123" }),
+        expect.any(Object),
+      );
+    });
+
+    it("should not expect Jazz's credentials using Email OTP for sign-in an already registered user", async () => {
+      // 1. User registration
+      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),
+        },
+      });
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(1);
+
+      // 2. Try to sign-in with OTP
+      let OTP: string = "";
+
+      sendVerificationOTPSpy.mockImplementationOnce(({ otp }) => {
+        OTP = otp;
+      });
+
+      await auth.api.sendVerificationOTP({
+        body: {
+          email: "test@example.com",
+          type: "sign-in",
+        },
+      });
+
+      expect(sendVerificationOTPSpy).toHaveBeenCalledTimes(1);
+      expect(verificationCreationSpy).toHaveBeenCalledTimes(1);
+
+      const result = await auth.api.signInEmailOTP({
+        body: {
+          email: "test@example.com",
+          otp: OTP,
+        },
+      });
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(1); // still only 1
+      expect(result).toMatchObject({
+        user: {
+          id: expect.any(String),
+          email: "test@example.com",
+          name: "test",
+        },
+      });
+    });
+  });
 });

package/src/inspector/custom-element.tsx

@@ -1,6 +1,6 @@
 import { Account } from "jazz-tools";
 import { createRoot } from "react-dom/client";
-import { JazzInspectorInternal } from "./index.js";
+import { JazzInspectorInternal } from "./viewer/new-app.js";
 
 export class JazzInspectorElement extends HTMLElement {
   private root: ReturnType<typeof createRoot> | null = null;

package/src/inspector/index.tsx

@@ -0,0 +1,44 @@
+import React from "react";
+
+export { JazzInspectorInternal } from "./viewer/new-app.js";
+export { PageStack } from "./viewer/page-stack.js";
+export { Breadcrumbs } from "./viewer/breadcrumbs.js";
+export { AccountOrGroupText } from "./viewer/account-or-group-text.js";
+
+export { Button } from "./ui/button.js";
+export { Input } from "./ui/input.js";
+export { Select } from "./ui/select.js";
+export { Icon } from "./ui/icon.js";
+export { GlobalStyles } from "./ui/global-styles.js";
+
+export {
+  resolveCoValue,
+  useResolvedCoValue,
+} from "./viewer/use-resolve-covalue.js";
+
+export type { PageInfo } from "./viewer/types.js";
+
+import { setup } from "goober";
+import { useJazzContext } from "jazz-tools/react-core";
+import { Account } from "jazz-tools";
+
+import { JazzInspectorInternal } from "./viewer/new-app.js";
+import { Position } from "./viewer/inpsector-button.js";
+
+export function JazzInspector({ position = "right" }: { position?: Position }) {
+  const context = useJazzContext<Account>();
+  const localNode = context.node;
+  const me = "me" in context ? context.me : undefined;
+
+  if (process.env.NODE_ENV !== "development") return null;
+
+  return (
+    <JazzInspectorInternal
+      position={position}
+      localNode={localNode}
+      accountId={me?.$jazz.raw.id}
+    />
+  );
+}
+
+setup(React.createElement);

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

@@ -1,6 +1,5 @@
 import { CoID, LocalNode, RawAccount, RawCoValue } from "cojson";
 import { styled } from "goober";
-import { useJazzContext } from "jazz-tools/react-core";
 import React, { useState } from "react";
 import { Button } from "../ui/button.js";
 import { Input } from "../ui/input.js";
@@ -8,7 +7,6 @@ import { Breadcrumbs } from "./breadcrumbs.js";
 import { PageStack } from "./page-stack.js";
 import { usePagePath } from "./use-page-path.js";
 
-import { Account } from "jazz-tools";
 import { GlobalStyles } from "../ui/global-styles.js";
 import { Heading } from "../ui/heading.js";
 import { InspectorButton, type Position } from "./inpsector-button.js";
@@ -61,22 +59,6 @@ const OrText = styled("p")`
   text-align: center;
 `;
 
-export function JazzInspector({ position = "right" }: { position?: Position }) {
-  const context = useJazzContext<Account>();
-  const localNode = context.node;
-  const me = "me" in context ? context.me : undefined;
-
-  if (process.env.NODE_ENV !== "development") return null;
-
-  return (
-    <JazzInspectorInternal
-      position={position}
-      localNode={localNode}
-      accountId={me?.$jazz.raw.id}
-    />
-  );
-}
-
 export function JazzInspectorInternal({
   position = "right",
   localNode,