jazz-tools 0.14.1 → 0.14.4

package/src/tests/coMap.test-d.ts

@@ -0,0 +1,348 @@
+import { assert, describe, expectTypeOf, test } from "vitest";
+import { Group, co, z } from "../exports.js";
+import { Account } from "../index.js";
+import { CoListSchema, Loaded } from "../internal.js";
+
+describe("CoMap", async () => {
+  describe("init", () => {
+    test("create a CoMap with basic property access", () => {
+      const Person = co.map({
+        color: z.string(),
+        _height: z.number(),
+        birthday: z.date(),
+        name: z.string(),
+        enum: z.enum(["a", "b", "c"]),
+        enumMap: z.enum({ a: 1, b: 2, c: 3 }),
+        optionalDate: z.date().optional(),
+      });
+
+      const birthday = new Date("1989-11-27");
+
+      const john = Person.create({
+        color: "red",
+        _height: 10,
+        birthday,
+        enum: "a",
+        enumMap: 1,
+        name: "John",
+      });
+
+      type ExpectedType = {
+        color: string;
+        _height: number;
+        birthday: Date;
+        name: string;
+        enum: "a" | "b" | "c";
+        enumMap: 1 | 2 | 3;
+        optionalDate: Date | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(john);
+    });
+
+    test("has the _owner property", () => {
+      const Person = co.map({
+        name: z.string(),
+      });
+
+      const john = Person.create({ name: "John" }, Account.getMe());
+
+      expectTypeOf(john._owner).toEqualTypeOf<Account | Group>();
+    });
+
+    test("CoMap with reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        dog: Dog,
+      });
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+      });
+
+      type ExpectedType = {
+        name: string;
+        age: number;
+        dog: Loaded<typeof Dog>;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
+
+    test("CoMap with optional reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        dog: Dog.optional(),
+      });
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+      });
+
+      type ExpectedType = {
+        name: string;
+        age: number;
+        dog: Loaded<typeof Dog> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
+
+    test("CoMap with self reference", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        // TODO: would be nice if this didn't need a type annotation
+        get friend(): z.ZodOptional<typeof Person> {
+          return z.optional(Person);
+        },
+      });
+
+      const person = Person.create({
+        name: "John",
+        age: 20,
+        friend: Person.create({ name: "Jane", age: 21 }),
+      });
+
+      type ExpectedType = {
+        name: string;
+        age: number;
+        friend: Loaded<typeof Person> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
+
+    test("should disallow extra properties", () => {
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+      });
+
+      // @ts-expect-error - x is not a valid property
+      Person.create({ name: "John", age: 30, xtra: 1 });
+    });
+  });
+
+  describe("Mutation", () => {
+    test("update a reference", () => {
+      const Dog = co.map({
+        name: z.string(),
+      });
+
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        dog: Dog,
+      });
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex" }),
+      });
+
+      john.dog = Dog.create({ name: "Fido" });
+    });
+
+    test("update a reference on a loaded value", () => {
+      const Dog = co.map({
+        name: z.string(),
+        get siblings(): CoListSchema<typeof Dog> {
+          return co.list(Dog);
+        },
+      });
+
+      const Person = co.map({
+        name: z.string(),
+        age: z.number(),
+        dog: Dog,
+      });
+
+      const john = Person.create({
+        name: "John",
+        age: 20,
+        dog: Dog.create({ name: "Rex", siblings: co.list(Dog).create([]) }),
+      }) as Loaded<typeof Person, { dog: { siblings: true } }>;
+
+      john.dog = Dog.create({
+        name: "Fido",
+        siblings: co.list(Dog).create([]),
+      });
+    });
+  });
+
+  test("Enum of maps", () => {
+    const ChildA = co.map({
+      type: z.literal("a"),
+      value: z.number(),
+    });
+
+    const ChildB = co.map({
+      type: z.literal("b"),
+      value: z.string(),
+    });
+
+    const MapWithEnumOfMaps = co.map({
+      name: z.string(),
+      child: z.discriminatedUnion([ChildA, ChildB]),
+    });
+
+    const mapWithEnum = MapWithEnumOfMaps.create({
+      name: "enum",
+      child: ChildA.create({
+        type: "a",
+        value: 5,
+      }),
+    });
+
+    type ExpectedType = {
+      name: string;
+      child: Loaded<typeof ChildA> | Loaded<typeof ChildB>;
+    };
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(mapWithEnum);
+
+    function matchesNarrowed(value: Loaded<typeof ChildA>) {
+      return value;
+    }
+
+    if (mapWithEnum.child.type === "a") {
+      matchesNarrowed(mapWithEnum.child);
+    }
+  });
+});
+
+describe("CoMap resolution", async () => {
+  test("partial loading a map with deep resolve", async () => {
+    const Dog = co.map({
+      name: z.string(),
+      breed: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+      dog1: Dog,
+      dog2: Dog,
+    });
+
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog1: Dog.create({ name: "Rex", breed: "Labrador" }),
+      dog2: Dog.create({ name: "Fido", breed: "Poodle" }),
+    });
+
+    const loadedPerson = await Person.load(person.id, {
+      resolve: {
+        dog1: true,
+      },
+    });
+
+    type ExpectedType = {
+      name: string;
+      age: number;
+      dog1: Loaded<typeof Dog>;
+      dog2: Loaded<typeof Dog> | null;
+    } | null;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(loadedPerson);
+
+    assert(loadedPerson);
+    expectTypeOf<typeof loadedPerson.dog1.name>().toEqualTypeOf<string>();
+    expectTypeOf<typeof loadedPerson.dog2>().toEqualTypeOf<Loaded<
+      typeof Dog
+    > | null>();
+  });
+
+  test("loading a map with deep resolve and $onError", async () => {
+    const Dog = co.map({
+      name: z.string(),
+      breed: z.string(),
+    });
+
+    const Person = co.map({
+      name: z.string(),
+      age: z.number(),
+      dog1: Dog,
+      dog2: Dog,
+    });
+
+    const person = Person.create({
+      name: "John",
+      age: 20,
+      dog1: Dog.create({ name: "Rex", breed: "Labrador" }),
+      dog2: Dog.create({ name: "Fido", breed: "Poodle" }),
+    });
+
+    const loadedPerson = await Person.load(person.id, {
+      resolve: {
+        dog1: true,
+        dog2: { $onError: null },
+      },
+    });
+
+    type ExpectedType = {
+      name: string;
+      age: number;
+      dog1: Loaded<typeof Dog>;
+      dog2: Loaded<typeof Dog> | null;
+    } | null;
+
+    function matches(value: ExpectedType) {
+      return value;
+    }
+
+    matches(loadedPerson);
+
+    assert(loadedPerson);
+    expectTypeOf<typeof loadedPerson.dog1.name>().toEqualTypeOf<string>();
+    expectTypeOf<typeof loadedPerson.dog2>().toEqualTypeOf<
+      | (Loaded<typeof Dog> & {
+          $onError: never; // TODO: Clean the $onError from the type
+        })
+      | null
+    >();
+  });
+});

package/src/tests/coMap.test.ts

@@ -34,6 +34,8 @@ describe("CoMap", async () => {
         _height: z.number(),
         birthday: z.date(),
         name: z.string(),
+        enum: z.enum(["a", "b", "c"]),
+        enumMap: z.enum({ a: 1, b: 2, c: 3 }),
         // nullable: z.optional.encoded<string | undefined>({
         //   encode: (value: string | undefined) => value || null,
         //   decode: (value: unknown) => (value as string) || undefined,
@@ -48,6 +50,8 @@ describe("CoMap", async () => {
         _height: 10,
         birthday,
         name: "John",
+        enum: "a",
+        enumMap: 1,
       });
 
       expect(john.color).toEqual("red");
@@ -59,7 +63,11 @@ describe("CoMap", async () => {
         "_height",
         "birthday",
         "name",
+        "enum",
+        "enumMap",
       ]);
+      expect(john.enum).toEqual("a");
+      expect(john.enumMap).toEqual(1);
     });
 
     test("property existence", () => {

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

@@ -0,0 +1,89 @@
+import { describe, expect, test, vi } from "vitest";
+import { InstanceOfSchema, Loaded, co, z } from "../../exports";
+import { createJazzTestAccount } from "../../testing";
+
+const QueuedNotification = co.map({
+  content: z.string(),
+  sent: z.boolean(),
+});
+
+const WorkerRoot = co.map({
+  notificationQueue: co.list(QueuedNotification),
+});
+
+const WorkerAccount = co
+  .account({
+    root: WorkerRoot,
+    profile: co.profile(),
+  })
+  .withMigration((account) => {
+    if (account.root === undefined) {
+      account.root = WorkerRoot.create({
+        notificationQueue: co.list(QueuedNotification).create([]),
+      });
+    }
+  });
+
+async function pushNotification(
+  worker: InstanceOfSchema<typeof WorkerAccount>,
+  content: string,
+) {
+  const workerAccount = await worker.ensureLoaded({
+    resolve: {
+      root: {
+        notificationQueue: {
+          $each: true,
+        },
+      },
+    },
+  });
+
+  const notification = QueuedNotification.create({
+    content,
+    sent: false,
+  });
+
+  workerAccount.root.notificationQueue.push(notification);
+
+  return notification;
+}
+
+async function sendAllThePendingNotifications(
+  worker: InstanceOfSchema<typeof WorkerAccount>,
+  sender: (notification: Loaded<typeof QueuedNotification>) => Promise<void>,
+) {
+  const workerAccount = await worker.ensureLoaded({
+    resolve: {
+      root: {
+        notificationQueue: {
+          $each: true,
+        },
+      },
+    },
+  });
+
+  for (const notification of workerAccount.root.notificationQueue) {
+    if (!notification.sent) {
+      notification.sent = true;
+      await sender(notification);
+    }
+  }
+}
+
+describe("Notifications", () => {
+  test("when pushing a notification, it should be added to the queue", async () => {
+    const worker = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      AccountSchema: WorkerAccount,
+    });
+
+    const notification = await pushNotification(worker, "Hello");
+
+    const spy = vi.fn();
+
+    await sendAllThePendingNotifications(worker, spy);
+
+    expect(notification.sent).toBe(true);
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tests/patterns/requestToJoin.test.ts

@@ -20,6 +20,7 @@ const Organization = co.map({
   statuses: RequestsStatus,
   projects: co.list(z.string()),
   mainGroup: Group,
+  adminsGroup: Group,
 });
 
 async function setup() {
@@ -65,6 +66,7 @@ async function setup() {
       // but this is the source of truth for admins
       statuses: RequestsStatus.create({}, adminsGroup),
       mainGroup: organizationGroup,
+      adminsGroup,
     },
     publicGroup,
   );
@@ -84,7 +86,7 @@ async function setup() {
 
 async function sendRequestToJoin(organizationId: string, account: Account) {
   const organization = await Organization.load(organizationId, {
-    resolve: { requests: true },
+    resolve: { requests: true, adminsGroup: true },
     loadAs: account,
   });
 
@@ -92,12 +94,15 @@ async function sendRequestToJoin(organizationId: string, account: Account) {
     throw new Error("RequestsMap not found");
   }
 
+  const group = Group.create(account);
+  group.extend(organization.adminsGroup);
+
   const request = RequestToJoin.create(
     {
       account,
       status: "pending",
     },
-    organization.requests._owner,
+    group,
   );
 
   organization.requests[account.id] = request;
@@ -264,8 +269,6 @@ describe("Request to join", () => {
 
     // With the writeOnly permission, the user can download the request
     // but not it's content
-    assert(requestOnUser2);
-    expect(requestOnUser2.status).toBe(undefined);
-    expect(requestOnUser2.account).toBe(undefined);
+    expect(requestOnUser2).toBeNull();
   });
 });