jazz-tools 0.18.14 → 0.18.16

package/src/better-auth/database-adapter/tests/repository/user.test.ts

@@ -0,0 +1,673 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Account, co } from "jazz-tools";
+import { startWorker } from "jazz-tools/worker";
+import { UserRepository } from "../../repository/user";
+import { createJazzSchema, Database } from "../../schema";
+import { createWorkerAccount, startSyncServer } from "../sync-utils.js";
+
+describe("UserRepository", () => {
+  let syncServer: any;
+
+  let databaseSchema: Database;
+  let databaseRoot: co.loaded<Database, { group: true }>;
+  let worker: Account;
+
+  beforeEach(async () => {
+    syncServer = await startSyncServer();
+
+    const workerAccount = await createWorkerAccount({
+      name: "test",
+      peer: `ws://localhost:${syncServer.port}`,
+    });
+
+    const JazzSchema = createJazzSchema({
+      user: {
+        modelName: "user",
+        fields: {
+          email: {
+            type: "string",
+            required: true,
+          },
+          name: {
+            type: "string",
+            required: false,
+          },
+        },
+      },
+      session: {
+        modelName: "session",
+        fields: {
+          userId: {
+            type: "string",
+            required: true,
+          },
+          token: {
+            type: "string",
+            required: true,
+          },
+        },
+      },
+    });
+
+    const result = await startWorker({
+      AccountSchema: JazzSchema.WorkerAccount,
+      syncServer: `ws://localhost:${syncServer.port}`,
+      accountID: workerAccount.accountID,
+      accountSecret: workerAccount.agentSecret,
+    });
+
+    databaseSchema = JazzSchema.DatabaseRoot;
+    databaseRoot = await JazzSchema.loadDatabase(result.worker);
+    worker = result.worker;
+  });
+
+  it("should create a user repository", async () => {
+    const userRepository = new UserRepository(
+      databaseSchema,
+      databaseRoot,
+      worker,
+    );
+    expect(userRepository).toBeDefined();
+  });
+
+  describe("create", () => {
+    it("should create a user with email index and sessions list", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      expect(user.$jazz.id).toBeDefined();
+      expect(user.email).toBe("test@example.com");
+      expect(user.name).toBe("Test User");
+      expect(user.sessions).toBeDefined();
+      expect(Array.isArray(user.sessions)).toBe(true);
+      expect(user.sessions.length).toBe(0);
+    });
+
+    it("should throw error when creating user with existing email", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      await expect(
+        userRepository.create("user", {
+          email: "test@example.com",
+          name: "Another User",
+        }),
+      ).rejects.toThrow("Email already exists");
+    });
+
+    it("should handle missing session schema gracefully", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      // This test verifies that the repository handles the case where
+      // the session schema exists (as required by createJazzSchema)
+      // but the session list schema lookup might fail
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      expect(user.$jazz.id).toBeDefined();
+      expect(user.email).toBe("test@example.com");
+      expect(user.sessions).toBeDefined();
+    });
+
+    it("should create multiple users with different emails", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user1 = await userRepository.create("user", {
+        email: "user1@example.com",
+        name: "User One",
+      });
+
+      const user2 = await userRepository.create("user", {
+        email: "user2@example.com",
+        name: "User Two",
+      });
+
+      expect(user1.$jazz.id).not.toBe(user2.$jazz.id);
+      expect(user1.email).toBe("user1@example.com");
+      expect(user2.email).toBe("user2@example.com");
+    });
+  });
+
+  describe("findMany", () => {
+    it("should find user by email using email index", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const createdUser = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      const users = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "test@example.com",
+          connector: "AND",
+        },
+      ]);
+
+      expect(users.length).toBe(1);
+      expect(users[0]?.$jazz.id).toBe(createdUser.$jazz.id);
+      expect(users[0]?.email).toBe("test@example.com");
+    });
+
+    it("should return empty array when finding non-existent email", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const users = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "nonexistent@example.com",
+          connector: "AND",
+        },
+      ]);
+
+      expect(users.length).toBe(0);
+    });
+
+    it("should find users with other where conditions using generic logic", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user1 = await userRepository.create("user", {
+        email: "user1@example.com",
+        name: "User One",
+      });
+
+      const user2 = await userRepository.create("user", {
+        email: "user2@example.com",
+        name: "User Two",
+      });
+
+      // Find all users
+      const allUsers = await userRepository.findMany("user", []);
+      expect(allUsers.length).toBe(2);
+
+      // Find by name
+      const usersByName = await userRepository.findMany("user", [
+        {
+          field: "name",
+          operator: "eq",
+          value: "User One",
+          connector: "AND",
+        },
+      ]);
+      expect(usersByName.length).toBe(1);
+      expect(usersByName[0]?.$jazz.id).toBe(user1.$jazz.id);
+    });
+
+    it("should find users by id using generic logic", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const createdUser = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      const users = await userRepository.findMany("user", [
+        {
+          field: "id",
+          operator: "eq",
+          value: createdUser.$jazz.id,
+          connector: "AND",
+        },
+      ]);
+
+      expect(users.length).toBe(1);
+      expect(users[0]?.$jazz.id).toBe(createdUser.$jazz.id);
+    });
+  });
+
+  describe("update", () => {
+    it("should update user without email change", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: user.$jazz.id,
+            connector: "AND",
+          },
+        ],
+        { name: "Updated User" },
+      );
+
+      const updatedUsers = await userRepository.findMany("user", [
+        { field: "id", operator: "eq", value: user.$jazz.id, connector: "AND" },
+      ]);
+
+      expect(updatedUsers.length).toBe(1);
+      expect(updatedUsers[0]?.name).toBe("Updated User");
+      expect(updatedUsers[0]?.email).toBe("test@example.com");
+    });
+
+    it("should update user email and maintain email index", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "old@example.com",
+        name: "Test User",
+      });
+
+      // Update email
+      const updatedUsers = await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: user.$jazz.id,
+            connector: "AND",
+          },
+        ],
+        { email: "new@example.com" },
+      );
+
+      expect(updatedUsers.length).toBe(1);
+      expect(updatedUsers[0]?.email).toBe("new@example.com");
+
+      // Verify old email is no longer findable
+      const oldEmailUsers = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "old@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(oldEmailUsers.length).toBe(0);
+
+      // Verify new email is findable
+      const newEmailUsers = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "new@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(newEmailUsers.length).toBe(1);
+      expect(newEmailUsers[0]?.$jazz.id).toBe(user.$jazz.id);
+    });
+
+    it("should update user email to null and remove from email index", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      // Update email to null
+      const updatedUsers = await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: user.$jazz.id,
+            connector: "AND",
+          },
+        ],
+        { email: null },
+      );
+
+      expect(updatedUsers.length).toBe(1);
+      expect(updatedUsers[0]?.email).toBe(null);
+
+      // Verify email is no longer findable
+      const emailUsers = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "test@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(emailUsers.length).toBe(0);
+    });
+
+    it("should handle update with no matching users", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const updatedUsers = await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: "non-existent-id",
+            connector: "AND",
+          },
+        ],
+        { name: "Updated" },
+      );
+
+      expect(updatedUsers.length).toBe(0);
+    });
+
+    it("should not update email index when email is undefined in update", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      // Update only name, not email
+      await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: user.$jazz.id,
+            connector: "AND",
+          },
+        ],
+        { name: "Updated User" },
+      );
+
+      // Verify email is still findable
+      const emailUsers = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "test@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(emailUsers.length).toBe(1);
+      expect(emailUsers[0]?.name).toBe("Updated User");
+    });
+  });
+
+  describe("deleteValue", () => {
+    it("should delete user and remove from email index", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      const deletedCount = await userRepository.deleteValue("user", [
+        { field: "id", operator: "eq", value: user.$jazz.id, connector: "AND" },
+      ]);
+
+      expect(deletedCount).toBe(1);
+
+      // Verify user is no longer findable
+      const users = await userRepository.findMany("user", []);
+      expect(users.length).toBe(0);
+
+      // Verify email is no longer findable
+      const emailUsers = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "test@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(emailUsers.length).toBe(0);
+    });
+
+    it("should delete multiple users and clean up email indexes", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user1 = await userRepository.create("user", {
+        email: "user1@example.com",
+        name: "User One",
+      });
+
+      const user2 = await userRepository.create("user", {
+        email: "user2@example.com",
+        name: "User Two",
+      });
+
+      // Delete all users
+      const deletedCount = await userRepository.deleteValue("user", []);
+      expect(deletedCount).toBe(2);
+
+      // Verify no users are findable
+      const users = await userRepository.findMany("user", []);
+      expect(users.length).toBe(0);
+
+      // Verify emails are no longer findable
+      const email1Users = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "user1@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(email1Users.length).toBe(0);
+
+      const email2Users = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "user2@example.com",
+          connector: "AND",
+        },
+      ]);
+      expect(email2Users.length).toBe(0);
+    });
+
+    it("should handle deletion with no matching users", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const deletedCount = await userRepository.deleteValue("user", [
+        {
+          field: "id",
+          operator: "eq",
+          value: "non-existent-id",
+          connector: "AND",
+        },
+      ]);
+
+      expect(deletedCount).toBe(0);
+    });
+
+    it("should clean up email index for user without email", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+        name: "Test User",
+      });
+
+      // First set email to null
+      await userRepository.update(
+        "user",
+        [
+          {
+            field: "id",
+            operator: "eq",
+            value: user.$jazz.id,
+            connector: "AND",
+          },
+        ],
+        { email: null },
+      );
+
+      // Then delete the user
+      const deletedCount = await userRepository.deleteValue("user", [
+        { field: "id", operator: "eq", value: user.$jazz.id, connector: "AND" },
+      ]);
+
+      expect(deletedCount).toBe(1);
+
+      // Verify no users remain
+      const users = await userRepository.findMany("user", []);
+      expect(users.length).toBe(0);
+    });
+  });
+
+  describe("email index management", () => {
+    it("should handle custom email field name from better auth schema", async () => {
+      const customSchema = createJazzSchema({
+        user: {
+          modelName: "user",
+          fields: {
+            emailAddress: {
+              type: "string",
+              required: true,
+            },
+          },
+        },
+        session: {
+          modelName: "session",
+          fields: {
+            userId: {
+              type: "string",
+              required: true,
+            },
+            token: {
+              type: "string",
+              required: true,
+            },
+          },
+        },
+      });
+
+      const userRepository = new UserRepository(
+        customSchema.DatabaseRoot,
+        databaseRoot,
+        worker,
+        {
+          user: {
+            modelName: "user",
+            fields: {
+              email: {
+                type: "string",
+                fieldName: "emailAddress",
+              },
+            },
+          },
+        },
+      );
+
+      const user = await userRepository.create("user", {
+        emailAddress: "test@example.com",
+      });
+
+      expect(user.emailAddress).toBe("test@example.com");
+
+      // Should be findable by the custom field name
+      const users = await userRepository.findMany("user", [
+        {
+          field: "email",
+          operator: "eq",
+          value: "test@example.com",
+          connector: "AND",
+        },
+      ]);
+
+      expect(users.length).toBe(1);
+      expect(users[0]?.$jazz.id).toBe(user.$jazz.id);
+    });
+
+    it("should default to 'email' field when no better auth schema is provided", async () => {
+      const userRepository = new UserRepository(
+        databaseSchema,
+        databaseRoot,
+        worker,
+      );
+
+      const user = await userRepository.create("user", {
+        email: "test@example.com",
+      });
+
+      expect(user.email).toBe("test@example.com");
+    });
+  });
+});