jazz-tools 0.18.0 → 0.18.1

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/tools/coValues/account.ts

@@ -418,6 +418,11 @@ class AccountJazzApi<A extends Account> extends CoValueJazzApi<A> {
     }
   }
 
+  has(key: "root" | "profile"): boolean {
+    const entry = this.raw.getRaw(key);
+    return entry?.change !== undefined && entry.change.op !== "del";
+  }
+
   /**
    * Get the descriptor for a given key
    * @internal

package/src/tools/coValues/coMap.ts

@@ -571,6 +571,20 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
     return getCoValueOwner(this.coMap);
   }
 
+  /**
+   * Check if a key is defined in the CoMap.
+   *
+   * This check does not load the referenced value or validate permissions.
+   *
+   * @param key The key to check
+   * @returns True if the key is defined, false otherwise
+   * @category Content
+   */
+  has(key: CoKeys<M>): boolean {
+    const entry = this.raw.getRaw(key);
+    return entry?.change !== undefined && entry.change.op !== "del";
+  }
+
   /**
    * Set a value on the CoMap
    *

package/src/tools/implementation/zodSchema/zodCo.ts

@@ -101,7 +101,7 @@ export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
  *   }),
  * }).withMigration(async (account) => {
  *   // Migration logic for existing accounts
- *   if (account.profile === undefined) {
+ *   if (!account.$jazz.has("profile")) {
  *     const group = Group.create();
  *     account.$jazz.set("profile", co.profile().create(
  *       { name: getRandomUsername() },

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

@@ -372,7 +372,7 @@ describe("ContextManager", () => {
         profile: co.profile(),
       })
       .withMigration(async (account) => {
-        if (account.root === undefined) {
+        if (!account.$jazz.has("root")) {
           account.$jazz.set(
             "root",
             AccountRoot.create({
@@ -429,7 +429,7 @@ describe("ContextManager", () => {
         profile: co.profile(),
       })
       .withMigration(async (account) => {
-        if (account.root === undefined) {
+        if (!account.$jazz.has("root")) {
           account.$jazz.set(
             "root",
             AccountRoot.create({

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

@@ -342,3 +342,54 @@ describe("root and profile", () => {
     expect(account.root.name).toBe("test 1");
   });
 });
+
+describe("account.$jazz.has", () => {
+  test("should return true if the key is defined", async () => {
+    const account = await createJazzTestAccount({
+      creationProps: { name: "John" },
+    });
+
+    expect(account.$jazz.has("profile")).toBe(true);
+    expect(account.$jazz.has("root")).toBe(false);
+  });
+
+  test("should work as migration check", async () => {
+    const CustomProfile = co.profile({
+      name: z.string(),
+      email: z.string().optional(),
+    });
+
+    const CustomRoot = co.map({
+      settings: z.string(),
+    });
+
+    const CustomAccount = co
+      .account({
+        profile: CustomProfile,
+        root: CustomRoot,
+      })
+      .withMigration((me, creationProps) => {
+        if (!me.$jazz.has("profile")) {
+          me.$jazz.set("profile", {
+            name: creationProps?.name ?? "Anonymous",
+            email: "test@example.com",
+          });
+        }
+
+        if (!me.$jazz.has("root")) {
+          me.$jazz.set("root", { settings: "default" });
+        }
+      });
+
+    const account = await createJazzTestAccount({
+      AccountSchema: CustomAccount,
+      creationProps: { name: "Custom User" },
+    });
+
+    expect(account.$jazz.has("profile")).toBe(true);
+    expect(account.$jazz.has("root")).toBe(true);
+
+    expect(account.profile.email).toBe("test@example.com");
+    expect(account.root.settings).toBe("default");
+  });
+});

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

@@ -744,6 +744,105 @@ describe("CoMap", async () => {
     });
   });
 
+  describe("has", () => {
+    test("should return true if the key is defined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John", age: 20 });
+
+      expect(person.$jazz.has("name")).toBe(true);
+      expect(person.$jazz.has("age")).toBe(true);
+    });
+
+    test("should return true if the key was set to undefined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      person.$jazz.set("age", undefined);
+
+      expect(person.$jazz.has("age")).toBe(true);
+    });
+
+    test("should return false if the key is not defined", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John" });
+
+      expect(person.$jazz.has("age")).toBe(false);
+    });
+
+    test("should return false if the key was deleted", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number().optional(),
+      });
+
+      const person = Person.create({ name: "John", age: 20 });
+
+      person.$jazz.delete("age");
+
+      expect(person.$jazz.has("age")).toBe(false);
+    });
+
+    test("should not load the referenced CoValue", async () => {
+      const Person = co.map({
+        name: co.plainText(),
+      });
+
+      const { clientAccount, serverAccount } = await setupTwoNodes();
+
+      const person = Person.create(
+        {
+          name: "John",
+        },
+        { owner: Group.create(serverAccount).makePublic() },
+      );
+
+      const loadedPerson = await Person.load(person.$jazz.id, {
+        resolve: true,
+        loadAs: clientAccount,
+      });
+
+      assert(loadedPerson);
+      expect(loadedPerson.$jazz.has("name")).toBe(true);
+      expect(loadedPerson.name).toBeNull();
+    });
+
+    test("should return true even if the viewer doesn't have access to the referenced CoValue", async () => {
+      const Person = co.map({
+        name: co.plainText(),
+      });
+
+      const person = Person.create(
+        // UserB has no access to name
+        { name: co.plainText().create("John", Group.create()) },
+        // UserB has access to person
+        { owner: Group.create().makePublic() },
+      );
+
+      const userB = await createJazzTestAccount();
+
+      const loadedPerson = await Person.load(person.$jazz.id, {
+        resolve: true,
+        loadAs: userB,
+      });
+
+      assert(loadedPerson);
+      expect(loadedPerson.$jazz.has("name")).toBe(true);
+      expect(loadedPerson.name).toBeNull();
+    });
+  });
+
   test("Enum of maps", () => {
     const ChildA = co.map({
       type: z.literal("a"),

package/src/tools/tests/patterns/notifications.test.ts

@@ -17,7 +17,7 @@ const WorkerAccount = co
     profile: co.profile(),
   })
   .withMigration((account) => {
-    if (account.root === undefined) {
+    if (!account.$jazz.has("root")) {
       account.$jazz.set("root", {
         notificationQueue: [],
       });

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

@@ -35,7 +35,7 @@ describe("Jazz Test Sync", () => {
         profile: co.profile(),
       })
       .withMigration((account) => {
-        if (account.root === undefined) {
+        if (!account.$jazz.has("root")) {
           account.$jazz.set("root", { value: "ok" });
         }
       });
@@ -59,7 +59,7 @@ describe("Jazz Test Sync", () => {
         profile: co.profile(),
       })
       .withMigration((account) => {
-        if (account.root === undefined) {
+        if (!account.$jazz.has("root")) {
           account.$jazz.set("root", { value: "ok" });
         }
       });

package/tsup.config.ts

@@ -137,4 +137,13 @@ export default defineConfig([
     },
     outDir: "dist/worker",
   },
+  {
+    ...cfg,
+    entry: {
+      client: "src/better-auth/auth/client.ts",
+      server: "src/better-auth/auth/server.ts",
+      react: "src/better-auth/auth/react.tsx",
+    },
+    outDir: "dist/better-auth/auth",
+  },
 ]);