jazz-tools 0.18.4 → 0.18.6

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

@@ -1,55 +1,55 @@
 import { betterAuth } from "better-auth";
 import { memoryAdapter } from "better-auth/adapters/memory";
-import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type Mock,
+} from "vitest";
+import { OAuth2Server } from "oauth2-mock-server";
 import { jazzPlugin } from "../server.js";
+import { emailOTP, genericOAuth } from "better-auth/plugins";
 
-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,
-          },
+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: [],
+        }),
+        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",
@@ -147,9 +147,7 @@ describe("Better Auth - Signup and Login Tests", () => {
         expect.any(Object),
       );
     });
-  });
 
-  describe("User login (Signin)", () => {
     it("should successfully login a new user with email and password", async () => {
       const userData = {
         name: "test",
@@ -194,7 +192,90 @@ describe("Better Auth - Signup and Login Tests", () => {
     });
   });
 
-  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: {
@@ -210,17 +291,202 @@ describe("Better Auth - Signup and Login Tests", () => {
         },
       });
 
-      expect(verificationCreationSpy).toHaveBeenCalledTimes(1);
-      expect(verificationCreationSpy).toHaveBeenCalledWith(
+      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 () => {
+      const response = await auth.api.signInSocial({
+        body: {
+          provider: providerId,
+          callbackURL: "http://localhost:3000/api/auth/sign-in/social/callback",
+          newUserCallbackURL:
+            "http://localhost:3000/api/auth/sign-in/social/callback",
+        },
+        headers: {
+          "x-jazz-auth": JSON.stringify({
+            accountID: "123",
+            secretSeed: [1, 2, 3],
+            accountSecret: "123",
+          }),
+        },
+      });
+
+      const oauthres = await fetch(response.url as string, {
+        redirect: "manual",
+      });
+
+      const resURL = new URL(oauthres.headers.get("Location") as string);
+
+      const callbackRes = await auth.handler(new Request(resURL));
+
+      expect(callbackRes.headers.getSetCookie()[0]).toMatch(
+        "better-auth.session_token=",
+      );
+
+      expect(accountCreationSpy).toHaveBeenCalledTimes(1);
+      expect(accountCreationSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ accountID: "123" }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  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.todo(
-      "should create a new account with jazz auth when using social provider",
-    );
+    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/browser/createBrowserContext.ts

@@ -214,6 +214,14 @@ export function provideBrowserLockSession(
   accountID: ID<Account> | AgentID,
   crypto: CryptoProvider,
 ) {
+  if (typeof navigator === "undefined" || !navigator.locks?.request) {
+    // Fallback to random session ID for each tab session
+    return Promise.resolve({
+      sessionID: crypto.newRandomSessionID(accountID as RawAccountID | AgentID),
+      sessionDone: () => {},
+    });
+  }
+
   let sessionDone!: () => void;
   const donePromise = new Promise<void>((resolve) => {
     sessionDone = resolve;

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,