jazz-tools 0.18.27 → 0.18.28

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

@@ -1833,439 +1833,6 @@ describe("CoMap Typescript validation", async () => {
 
     expect(loadedMap).not.toBe("unavailable");
   });
-});
-
-describe("Creating and finding unique CoMaps", async () => {
-  test("Creating and finding unique CoMaps", async () => {
-    const group = Group.create();
-
-    const Person = co.map({
-      name: z.string(),
-      _height: z.number(),
-      birthday: z.date(),
-      color: z.string(),
-    });
-
-    const alice = Person.create(
-      {
-        name: "Alice",
-        _height: 100,
-        birthday: new Date("1990-01-01"),
-        color: "red",
-      },
-      { owner: group, unique: { name: "Alice" } },
-    );
-
-    const foundAlice = await Person.loadUnique(
-      { name: "Alice" },
-      group.$jazz.id,
-    );
-    expect(foundAlice).toEqual(alice);
-  });
-
-  test("manual upserting pattern", async () => {
-    // Schema
-    const Event = co.map({
-      title: z.string(),
-      identifier: z.string(),
-      external_id: z.string(),
-    });
-
-    // Data
-    const sourceData = {
-      title: "Test Event Title",
-      identifier: "test-event-identifier",
-      _id: "test-event-external-id",
-    };
-    const workspace = Group.create();
-
-    // Pattern
-    let activeEvent = await Event.loadUnique(
-      { identifier: sourceData.identifier },
-      workspace.$jazz.id,
-    );
-    if (!activeEvent) {
-      activeEvent = Event.create(
-        {
-          title: sourceData.title,
-          identifier: sourceData.identifier,
-          external_id: sourceData._id,
-        },
-        workspace,
-      );
-    } else {
-      activeEvent.$jazz.applyDiff({
-        title: sourceData.title,
-        identifier: sourceData.identifier,
-        external_id: sourceData._id,
-      });
-    }
-    expect(activeEvent).toEqual({
-      title: sourceData.title,
-      identifier: sourceData.identifier,
-      external_id: sourceData._id,
-    });
-  });
-
-  test("upserting a non-existent value", async () => {
-    // Schema
-    const Event = co.map({
-      title: z.string(),
-      identifier: z.string(),
-      external_id: z.string(),
-    });
-
-    // Data
-    const sourceData = {
-      title: "Test Event Title",
-      identifier: "test-event-identifier",
-      _id: "test-event-external-id",
-    };
-    const workspace = Group.create();
-
-    // Upserting
-    const activeEvent = await Event.upsertUnique({
-      value: {
-        title: sourceData.title,
-        identifier: sourceData.identifier,
-        external_id: sourceData._id,
-      },
-      unique: sourceData.identifier,
-      owner: workspace,
-    });
-    expect(activeEvent).toEqual({
-      title: sourceData.title,
-      identifier: sourceData.identifier,
-      external_id: sourceData._id,
-    });
-  });
-
-  test("upserting without an active account", async () => {
-    const account = activeAccountContext.get();
-
-    // Schema
-    const Event = co.map({
-      title: z.string(),
-      identifier: z.string(),
-      external_id: z.string(),
-    });
-
-    // Data
-    const sourceData = {
-      title: "Test Event Title",
-      identifier: "test-event-identifier",
-      _id: "test-event-external-id",
-    };
-
-    const activeEvent = await runWithoutActiveAccount(() => {
-      return Event.upsertUnique({
-        value: {
-          title: sourceData.title,
-          identifier: sourceData.identifier,
-          external_id: sourceData._id,
-        },
-        unique: sourceData.identifier,
-        owner: account,
-      });
-    });
-
-    expect(activeEvent).toEqual({
-      title: sourceData.title,
-      identifier: sourceData.identifier,
-      external_id: sourceData._id,
-    });
-
-    assert(activeEvent);
-
-    expect(activeEvent.$jazz.owner).toEqual(account);
-  });
-
-  test("upserting an existing value", async () => {
-    // Schema
-    const Event = co.map({
-      title: z.string(),
-      identifier: z.string(),
-      external_id: z.string(),
-    });
-
-    // Data
-    const oldSourceData = {
-      title: "Old Event Title",
-      identifier: "test-event-identifier",
-      _id: "test-event-external-id",
-    };
-    const newSourceData = {
-      title: "New Event Title",
-      identifier: "test-event-identifier",
-      _id: "test-event-external-id",
-    };
-    expect(oldSourceData.identifier).toEqual(newSourceData.identifier);
-    const workspace = Group.create();
-    const oldActiveEvent = Event.create(
-      {
-        title: oldSourceData.title,
-        identifier: oldSourceData.identifier,
-        external_id: oldSourceData._id,
-      },
-      workspace,
-    );
-
-    // Upserting
-    const activeEvent = await Event.upsertUnique({
-      value: {
-        title: newSourceData.title,
-        identifier: newSourceData.identifier,
-        external_id: newSourceData._id,
-      },
-      unique: newSourceData.identifier,
-      owner: workspace,
-    });
-    expect(activeEvent).toEqual({
-      title: newSourceData.title,
-      identifier: newSourceData.identifier,
-      external_id: newSourceData._id,
-    });
-    expect(activeEvent).not.toEqual(oldActiveEvent);
-  });
-
-  test("upserting a non-existent value with resolve", async () => {
-    const Project = co.map({
-      name: z.string(),
-    });
-    const Organisation = co.map({
-      name: z.string(),
-      projects: co.list(Project),
-    });
-    const workspace = Group.create();
-
-    const myOrg = await Organisation.upsertUnique({
-      value: {
-        name: "My organisation",
-        projects: co.list(Project).create(
-          [
-            Project.create(
-              {
-                name: "My project",
-              },
-              workspace,
-            ),
-          ],
-          workspace,
-        ),
-      },
-      unique: { name: "My organisation" },
-      owner: workspace,
-      resolve: {
-        projects: {
-          $each: true,
-        },
-      },
-    });
-    assert(myOrg);
-    expect(myOrg).not.toBeNull();
-    expect(myOrg.name).toEqual("My organisation");
-    expect(myOrg.projects.length).toBe(1);
-    expect(myOrg.projects[0]).toMatchObject({
-      name: "My project",
-    });
-  });
-
-  test("upserting an existing value with resolve", async () => {
-    const Project = co.map({
-      name: z.string(),
-    });
-    const Organisation = co.map({
-      name: z.string(),
-      projects: co.list(Project),
-    });
-    const workspace = Group.create();
-    const initialProject = await Project.upsertUnique({
-      value: {
-        name: "My project",
-      },
-      unique: { unique: "First project" },
-      owner: workspace,
-    });
-    assert(initialProject);
-    expect(initialProject).not.toBeNull();
-    expect(initialProject.name).toEqual("My project");
-
-    const myOrg = await Organisation.upsertUnique({
-      value: {
-        name: "My organisation",
-        projects: co.list(Project).create([initialProject], workspace),
-      },
-      unique: { name: "My organisation" },
-      owner: workspace,
-      resolve: {
-        projects: {
-          $each: true,
-        },
-      },
-    });
-    assert(myOrg);
-    expect(myOrg).not.toBeNull();
-    expect(myOrg.name).toEqual("My organisation");
-    expect(myOrg.projects.length).toBe(1);
-    expect(myOrg.projects.at(0)?.name).toEqual("My project");
-
-    const updatedProject = await Project.upsertUnique({
-      value: {
-        name: "My updated project",
-      },
-      unique: { unique: "First project" },
-      owner: workspace,
-    });
-
-    assert(updatedProject);
-    expect(updatedProject).not.toBeNull();
-    expect(updatedProject).toEqual(initialProject);
-    expect(updatedProject.name).toEqual("My updated project");
-    expect(myOrg.projects.length).toBe(1);
-    expect(myOrg.projects.at(0)?.name).toEqual("My updated project");
-  });
-
-  test("upserting a partially loaded value on an new value with resolve", async () => {
-    const Project = co.map({
-      name: z.string(),
-    });
-    const Organisation = co.map({
-      name: z.string(),
-      projects: co.list(Project),
-    });
-    const publicAccess = Group.create();
-    publicAccess.addMember("everyone", "writer");
-
-    const initialProject = await Project.upsertUnique({
-      value: {
-        name: "My project",
-      },
-      unique: { unique: "First project" },
-      owner: publicAccess,
-    });
-    assert(initialProject);
-    expect(initialProject).not.toBeNull();
-    expect(initialProject.name).toEqual("My project");
-
-    const fullProjectList = co
-      .list(Project)
-      .create([initialProject], publicAccess);
-
-    const account = await createJazzTestAccount({
-      isCurrentActiveAccount: true,
-    });
-
-    const shallowProjectList = await co
-      .list(Project)
-      .load(fullProjectList.$jazz.id, {
-        loadAs: account,
-      });
-    assert(shallowProjectList);
-
-    const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
-      loadAs: account,
-    });
-    assert(publicAccessAsNewAccount);
-
-    const updatedOrg = await Organisation.upsertUnique({
-      value: {
-        name: "My organisation",
-        projects: shallowProjectList,
-      },
-      unique: { name: "My organisation" },
-      owner: publicAccessAsNewAccount,
-      resolve: {
-        projects: {
-          $each: true,
-        },
-      },
-    });
-
-    assert(updatedOrg);
-
-    expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
-    expect(updatedOrg.projects.length).toBe(1);
-    expect(updatedOrg.projects.at(0)?.name).toEqual("My project");
-  });
-
-  test("upserting a partially loaded value on an existing value with resolve", async () => {
-    const Project = co.map({
-      name: z.string(),
-    });
-    const Organisation = co.map({
-      name: z.string(),
-      projects: co.list(Project),
-    });
-    const publicAccess = Group.create();
-    publicAccess.addMember("everyone", "writer");
-
-    const initialProject = await Project.upsertUnique({
-      value: {
-        name: "My project",
-      },
-      unique: { unique: "First project" },
-      owner: publicAccess,
-    });
-    assert(initialProject);
-    expect(initialProject).not.toBeNull();
-    expect(initialProject.name).toEqual("My project");
-
-    const myOrg = await Organisation.upsertUnique({
-      value: {
-        name: "My organisation",
-        projects: co.list(Project).create([], publicAccess),
-      },
-      unique: { name: "My organisation" },
-      owner: publicAccess,
-      resolve: {
-        projects: {
-          $each: true,
-        },
-      },
-    });
-    assert(myOrg);
-
-    const fullProjectList = co
-      .list(Project)
-      .create([initialProject], publicAccess);
-
-    const account = await createJazzTestAccount({
-      isCurrentActiveAccount: true,
-    });
-
-    const shallowProjectList = await co
-      .list(Project)
-      .load(fullProjectList.$jazz.id, {
-        loadAs: account,
-      });
-    assert(shallowProjectList);
-
-    const publicAccessAsNewAccount = await Group.load(publicAccess.$jazz.id, {
-      loadAs: account,
-    });
-    assert(publicAccessAsNewAccount);
-
-    const updatedOrg = await Organisation.upsertUnique({
-      value: {
-        name: "My organisation",
-        projects: shallowProjectList,
-      },
-      unique: { name: "My organisation" },
-      owner: publicAccessAsNewAccount,
-      resolve: {
-        projects: {
-          $each: true,
-        },
-      },
-    });
-
-    assert(updatedOrg);
-
-    expect(updatedOrg.projects.$jazz.id).toEqual(fullProjectList.$jazz.id);
-    expect(updatedOrg.projects.length).toBe(1);
-    expect(updatedOrg.projects.at(0)?.name).toEqual("My project");
-    expect(updatedOrg.$jazz.id).toEqual(myOrg.$jazz.id);
-  });
 
   test("complex discriminated union", () => {
     const StringTag = co.map({