jazz-tools 0.19.16 → 0.19.17

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

@@ -1,81 +1,61 @@
 import { describe, expect, it } from "vitest";
 import { getClerkUsername } from "../getClerkUsername.js";
-import type { MinimalClerkClient } from "../types.js";
+import type { ClerkUser } from "../types.js";
 
 describe("getClerkUsername", () => {
-  it("should return null if no user", () => {
-    const mockClerk = {
-      user: null,
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe(null);
-  });
-
   it("should return fullName if available", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         fullName: "John Doe",
         firstName: "John",
         lastName: "Doe",
         username: "johndoe",
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("John Doe");
+      } as ClerkUser),
+    ).toBe("John Doe");
   });
 
   it("should return firstName + lastName if available and no fullName", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         firstName: "John",
         lastName: "Doe",
         username: "johndoe",
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("John Doe");
+      } as ClerkUser),
+    ).toBe("John Doe");
   });
 
   it("should return firstName if available and no lastName or fullName", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         firstName: "John",
         username: "johndoe",
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("John");
+      } as ClerkUser),
+    ).toBe("John");
   });
 
   it("should return username if available and no names", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         username: "johndoe",
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("johndoe");
+      } as ClerkUser),
+    ).toBe("johndoe");
   });
 
   it("should return email username if available and no other identifiers", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         primaryEmailAddress: {
           emailAddress: "john.doe@example.com",
         },
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("john.doe");
+      } as ClerkUser),
+    ).toBe("john.doe");
   });
 
   it("should return user id as last resort", () => {
-    const mockClerk = {
-      user: {
+    expect(
+      getClerkUsername({
         id: "user_123",
-      },
-    } as MinimalClerkClient;
-
-    expect(getClerkUsername(mockClerk)).toBe("user_123");
+      } as ClerkUser),
+    ).toBe("user_123");
   });
 });

package/src/tools/auth/clerk/tests/isClerkAuthStateEqual.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { isClerkAuthStateEqual } from "../types";
+import { ClerkUser, isClerkAuthStateEqual } from "../types";
 
 describe("isClerkAuthStateEqual", () => {
   const validCredentials = {
@@ -91,7 +91,9 @@ describe("isClerkAuthStateEqual", () => {
         description: "both have incomplete credentials",
       },
     ])("returns true when $description", ({ previous, next }) => {
-      expect(isClerkAuthStateEqual(previous, next)).toBe(true);
+      expect(
+        isClerkAuthStateEqual(previous as ClerkUser, next as ClerkUser),
+      ).toBe(true);
     });
   });
 
@@ -118,7 +120,9 @@ describe("isClerkAuthStateEqual", () => {
         description: "previous has incomplete, next has credentials",
       },
     ])("returns false when $description", ({ previous, next }) => {
-      expect(isClerkAuthStateEqual(previous, next)).toBe(false);
+      expect(
+        isClerkAuthStateEqual(previous as ClerkUser, next as ClerkUser),
+      ).toBe(false);
     });
   });
 });

package/src/tools/auth/clerk/tests/{types.test.ts → isClerkCredentials.test.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { isClerkCredentials } from "../types";
+import { ClerkUser, isClerkCredentials } from "../types";
 
 describe("isClerkCredentials", () => {
   it.each([
@@ -44,6 +44,8 @@ describe("isClerkCredentials", () => {
       description: "missing jazzAccountSecret",
     },
   ])("fails for invalid credentials: $description", ({ metadata }) => {
-    expect(isClerkCredentials(metadata)).toBe(false);
+    expect(isClerkCredentials(metadata as ClerkUser["unsafeMetadata"])).toBe(
+      false,
+    );
   });
 });

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

@@ -1,32 +1,57 @@
-import { AgentSecret } from "cojson";
-import { Account, ID } from "jazz-tools";
+import { type AgentSecret } from "cojson";
+import { z } from "zod/v4";
+
+const ClerkJazzCredentialsSchema = z.object({
+  jazzAccountID: z.string(),
+  jazzAccountSecret: z.string(),
+  jazzAccountSeed: z.array(z.number()).optional(),
+});
+
+const ClerkUserSchema = z.object({
+  fullName: z.string().nullish(),
+  username: z.string().nullish(),
+  firstName: z.string().nullish(),
+  lastName: z.string().nullish(),
+  id: z.string().optional(),
+  primaryEmailAddress: z
+    .object({
+      emailAddress: z.string().nullable(),
+    })
+    .nullish(),
+  unsafeMetadata: z.union([z.object({}), ClerkJazzCredentialsSchema]),
+  update: z.function({
+    input: [
+      z.object({
+        unsafeMetadata: ClerkJazzCredentialsSchema,
+      }),
+    ],
+    output: z.promise(z.unknown()),
+  }),
+});
+
+export const ClerkEventSchema = z.object({
+  user: ClerkUserSchema.nullish(),
+});
+export type ClerkEventSchema = z.infer<typeof ClerkEventSchema>;
+
+export type ClerkUser = z.infer<typeof ClerkUserSchema>;
+
+// Need to provide a permissive type externally to accept
+type PermissiveClerkUser = Omit<ClerkUser, "unsafeMetadata" | "update"> & {
+  unsafeMetadata: Record<string, unknown>;
+  update: (args: {
+    unsafeMetadata: Record<string, unknown>;
+  }) => Promise<unknown>;
+};
 
 export type MinimalClerkClient = {
-  user:
-    | {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        unsafeMetadata: Record<string, any>;
-        fullName: string | null;
-        username: string | null;
-        firstName: string | null;
-        lastName: string | null;
-        id: string;
-        primaryEmailAddress: {
-          emailAddress: string | null;
-        } | null;
-        update: (args: {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          unsafeMetadata: Record<string, any>;
-        }) => Promise<unknown>;
-      }
-    | null
-    | undefined;
+  user: PermissiveClerkUser | null | undefined;
   signOut: () => Promise<void>;
   addListener: (listener: (data: unknown) => void) => void;
 };
 
 export type ClerkCredentials = {
-  jazzAccountID: ID<Account>;
+  jazzAccountID: string;
   jazzAccountSecret: AgentSecret;
   jazzAccountSeed?: number[];
 };
@@ -36,23 +61,19 @@ export type ClerkCredentials = {
  * **Note**: It does not validate the credentials, only checks if the necessary fields are present in the metadata object.
  */
 export function isClerkCredentials(
-  data:
-    | NonNullable<MinimalClerkClient["user"]>["unsafeMetadata"]
-    | null
-    | undefined,
+  data: Record<string, unknown> | undefined,
 ): data is ClerkCredentials {
   return !!data && "jazzAccountID" in data && "jazzAccountSecret" in data;
 }
 
+type ClerkUserWithUnsafeMetadata =
+  | Pick<ClerkUser, "unsafeMetadata">
+  | null
+  | undefined;
+
 export function isClerkAuthStateEqual(
-  previousUser:
-    | Pick<NonNullable<MinimalClerkClient["user"]>, "unsafeMetadata">
-    | null
-    | undefined,
-  newUser:
-    | Pick<NonNullable<MinimalClerkClient["user"]>, "unsafeMetadata">
-    | null
-    | undefined,
+  previousUser: ClerkUserWithUnsafeMetadata,
+  newUser: ClerkUserWithUnsafeMetadata,
 ) {
   if (Boolean(previousUser) !== Boolean(newUser)) {
     return false;

package/src/tools/implementation/ContextManager.ts

@@ -188,24 +188,45 @@ export class JazzContextManager<
     return this.subscriptionCache;
   }
 
+  /**
+   * Flag to indicate if a logout operation is currently in progress.
+   * Used to prevent concurrent logout attempts or double-logout issues.
+   * Set to true when logout starts, reset to false once all logout logic runs.
+   */
+  loggingOut = false;
+
+  /**
+   * Handles the logout process.
+   * Uses the loggingOut flag to ensure only one logout can happen at a time.
+   */
   logOut = async () => {
-    if (!this.context || !this.props) {
+    if (!this.context || !this.props || this.loggingOut) {
       return;
     }
 
+    // Mark as logging out to prevent reentry
+    this.loggingOut = true;
+
     this.authenticatingAccountID = null;
 
     // Clear cache on logout to prevent subscription leaks across authentication boundaries
     this.subscriptionCache.clear();
 
-    await this.props.onLogOut?.();
+    try {
+      await this.props.onLogOut?.();
 
-    if (this.props.logOutReplacement) {
-      await this.props.logOutReplacement();
-    } else {
-      await this.context.logOut();
-      return this.createContext(this.props);
+      if (this.props.logOutReplacement) {
+        await this.props.logOutReplacement();
+      } else {
+        await this.context.logOut();
+        await this.createContext(this.props);
+      }
+    } catch (error) {
+      console.error("Error during logout", error);
     }
+
+    // Reset flag after standard logout finishes
+    this.loggingOut = false;
   };
 
   done = () => {

package/src/tools/tests/ContextManager.test.ts

@@ -604,6 +604,22 @@ describe("ContextManager", () => {
       expect(onAnonymousAccountDiscarded).toHaveBeenCalledTimes(1);
     });
 
+    test("prevents concurrent logout attempts", async () => {
+      const onLogOut = vi.fn();
+      await manager.createContext({ onLogOut });
+
+      // Start multiple concurrent logout attempts
+      const promises = [];
+      for (let i = 0; i < 5; i++) {
+        promises.push(manager.logOut());
+      }
+
+      await Promise.all(promises);
+
+      // onLogOut should only be called once despite multiple logOut calls
+      expect(onLogOut).toHaveBeenCalledTimes(1);
+    });
+
     test("allows authentication after logout", async () => {
       const account = await createJazzTestAccount();
       const onAnonymousAccountDiscarded = vi.fn();

package/dist/tools/auth/clerk/tests/types.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.test.d.ts.map

package/dist/tools/auth/clerk/tests/types.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.test.d.ts","sourceRoot":"","sources":["../../../../../src/tools/auth/clerk/tests/types.test.ts"],"names":[],"mappings":""}