jazz-tools 0.16.2 → 0.16.3

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.ts

@@ -1,137 +1,13 @@
-import { JsonValue } from "cojson";
 import {
-  Account,
   AnyZodOrCoValueSchema,
-  CoDiscriminatedUnionSchema,
-  CoFeed,
-  CoList,
-  CoMap,
-  CoPlainText,
-  CoRichText,
   CoValueClass,
-  CoreAccountSchema,
-  CoreCoRecordSchema,
-  FileStream,
-  InstanceOrPrimitiveOfSchema,
-  Profile,
+  InstanceOfSchemaCoValuesNullable,
 } from "../../../internal.js";
-import { CoreCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
-import { CoreCoListSchema } from "../schemaTypes/CoListSchema.js";
-import { CoreCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
-import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
-import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
+import { TypeOfZodSchema } from "./TypeOfZodSchema.js";
 
 export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
   S extends CoValueClass | AnyZodOrCoValueSchema,
-> = S extends CoreCoValueSchema
-  ? S extends CoreAccountSchema<infer Shape>
-    ?
-        | ({
-            -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
-              Shape[key]
-            >;
-          } & { profile: Profile | null } & Account)
-        | null
-    : S extends CoreCoRecordSchema<infer K, infer V>
-      ?
-          | ({
-              -readonly [key in z.output<K> &
-                string]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
-            } & CoMap)
-          | null
-      : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
-        ?
-            | ({
-                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
-                  Shape[key]
-                >;
-              } & (CatchAll extends AnyZodOrCoValueSchema
-                ? {
-                    [
-                      key: string
-                    ]: InstanceOrPrimitiveOfSchemaCoValuesNullable<CatchAll>;
-                  }
-                : {}) &
-                CoMap)
-            | null
-        : S extends CoreCoListSchema<infer T>
-          ? CoList<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-          : S extends CoreCoFeedSchema<infer T>
-            ? CoFeed<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-            : S extends CorePlainTextSchema
-              ? CoPlainText | null
-              : S extends CoreRichTextSchema
-                ? CoRichText | null
-                : S extends CoreFileStreamSchema
-                  ? FileStream | null
-                  : S extends CoreCoOptionalSchema<infer T>
-                    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T> | undefined
-                    : S extends CoDiscriminatedUnionSchema<infer Members>
-                      ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
-                          Members[number]
-                        >
-                      : never
-  : S extends z.core.$ZodType
-    ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
-      ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner> | undefined
-      : S extends z.core.$ZodNullable<infer Inner extends z.core.$ZodType>
-        ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner> | null
-        : S extends z.ZodJSONSchema
-          ? JsonValue
-          : S extends z.core.$ZodUnion<
-                infer Members extends readonly z.core.$ZodType[]
-              >
-            ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Members[number]>
-            : // primitives below here - we manually traverse to ensure we only allow what we can handle
-              S extends z.core.$ZodObject<infer Shape>
-              ? {
-                  -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                    Shape[key]
-                  >;
-                }
-              : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
-                ? InstanceOrPrimitiveOfSchema<Item>[]
-                : S extends z.core.$ZodTuple<
-                      infer Items extends z.core.$ZodType[]
-                    >
-                  ? {
-                      [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                        Items[key]
-                      >;
-                    }
-                  : S extends z.core.$ZodString
-                    ? string
-                    : S extends z.core.$ZodNumber
-                      ? number
-                      : S extends z.core.$ZodBoolean
-                        ? boolean
-                        : S extends z.core.$ZodLiteral<infer Literal>
-                          ? Literal
-                          : S extends z.core.$ZodDate
-                            ? Date
-                            : S extends z.core.$ZodEnum<infer Enum>
-                              ? Enum[keyof Enum]
-                              : S extends z.core.$ZodTemplateLiteral<
-                                    infer pattern
-                                  >
-                                ? pattern
-                                : S extends z.core.$ZodReadonly<
-                                      infer Inner extends z.core.$ZodType
-                                    >
-                                  ? InstanceOrPrimitiveOfSchema<Inner>
-                                  : S extends z.core.$ZodDefault<
-                                        infer Default extends z.core.$ZodType
-                                      >
-                                    ? InstanceOrPrimitiveOfSchema<Default>
-                                    : S extends z.core.$ZodCatch<
-                                          infer Catch extends z.core.$ZodType
-                                        >
-                                      ? InstanceOrPrimitiveOfSchema<Catch>
-                                      : never
-    : S extends CoValueClass
-      ? InstanceType<S> | null
-      : never;
+> = S extends z.core.$ZodType
+  ? TypeOfZodSchema<S>
+  : InstanceOfSchemaCoValuesNullable<S>;

package/src/tools/implementation/zodSchema/typeConverters/TypeOfZodSchema.ts

@@ -0,0 +1,79 @@
+import { JsonValue } from "cojson";
+import { PartialOnUndefined } from "../../../internal.js";
+import { z } from "../zodReExport.js";
+
+// Copied from https://github.com/colinhacks/zod/blob/7e7e3461aceecf3633e158df50d6bc852e7cdf45/packages/zod/src/v4/core/schemas.ts#L1591,
+// since this type is not exported by Zod
+type OptionalInSchema = {
+  _zod: {
+    optin: "optional";
+  };
+};
+
+/**
+ * Get type from Zod schema definition.
+ *
+ * Similar to `z.infer`, but we manually traverse Zod types to ensure we only allow what we can handle
+ */
+export type TypeOfZodSchema<S extends z.core.$ZodType> =
+  S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
+    ? TypeOfZodSchema<Inner> | undefined
+    : S extends z.core.$ZodNullable<infer Inner extends z.core.$ZodType>
+      ? TypeOfZodSchema<Inner> | null
+      : S extends z.ZodJSONSchema
+        ? JsonValue
+        : S extends z.core.$ZodUnion<
+              infer Members extends readonly z.core.$ZodType[]
+            >
+          ? TypeOfZodSchema<Members[number]>
+          : S extends z.core.$ZodObject<infer Shape>
+            ? /**
+               * Cannot use {@link PartialOnUndefined} because evaluating TypeOfZodSchema<Shape[key]>
+               * to know if the value can be undefined does not work with recursive types.
+               */
+              {
+                -readonly [key in keyof Shape as Shape[key] extends OptionalInSchema
+                  ? never
+                  : key]: TypeOfZodSchema<Shape[key]>;
+              } & {
+                -readonly [key in keyof Shape as Shape[key] extends OptionalInSchema
+                  ? key
+                  : never]?: TypeOfZodSchema<Shape[key]>;
+              }
+            : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
+              ? TypeOfZodSchema<Item>[]
+              : S extends z.core.$ZodTuple<
+                    infer Items extends readonly z.core.$ZodType[]
+                  >
+                ? {
+                    [key in keyof Items]: TypeOfZodSchema<Items[key]>;
+                  }
+                : S extends z.core.$ZodString
+                  ? string
+                  : S extends z.core.$ZodNumber
+                    ? number
+                    : S extends z.core.$ZodBoolean
+                      ? boolean
+                      : S extends z.core.$ZodLiteral<infer Literal>
+                        ? Literal
+                        : S extends z.core.$ZodDate
+                          ? Date
+                          : S extends z.core.$ZodEnum<infer Enum>
+                            ? Enum[keyof Enum]
+                            : S extends z.core.$ZodTemplateLiteral<
+                                  infer pattern
+                                >
+                              ? pattern
+                              : S extends z.core.$ZodReadonly<
+                                    infer Inner extends z.core.$ZodType
+                                  >
+                                ? TypeOfZodSchema<Inner>
+                                : S extends z.core.$ZodDefault<
+                                      infer Default extends z.core.$ZodType
+                                    >
+                                  ? TypeOfZodSchema<Default>
+                                  : S extends z.core.$ZodCatch<
+                                        infer Catch extends z.core.$ZodType
+                                      >
+                                    ? TypeOfZodSchema<Catch>
+                                    : never;

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

@@ -7,6 +7,7 @@ import {
   CoreCoMapSchema,
   DiscriminableCoValueSchemas,
   DiscriminableCoreCoValueSchema,
+  SchemaUnionDiscriminator,
 } from "../../internal.js";
 import {
   hydrateCoreCoValueSchema,
@@ -56,21 +57,17 @@ export function schemaUnionDiscriminatorFor(
       }
     }
 
-    const determineSchema = (_raw: RawCoMap | RawAccount | RawCoList) => {
-      if (_raw instanceof RawCoList) {
-        throw new Error(
-          "co.discriminatedUnion() of collaborative types is not supported for CoLists",
-        );
-      }
-
+    const determineSchema: SchemaUnionDiscriminator<CoMap> = (
+      discriminable,
+    ) => {
       for (const option of availableOptions) {
         let match = true;
 
         for (const key of Object.keys(discriminatorMap)) {
           const discriminatorDef = (option as CoreCoMapSchema).getDefinition()
-            .shape[key as string];
+            .shape[key];
 
-          const discriminatorValue = (_raw as RawCoMap).get(key as string);
+          const discriminatorValue = discriminable.get(key);
 
           if (discriminatorValue && typeof discriminatorValue === "object") {
             throw new Error("Discriminator must be a primitive value");

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

@@ -23,11 +23,7 @@ import {
 } from "./schemaTypes/CoDiscriminatedUnionSchema.js";
 import { CoFeedSchema, CoreCoFeedSchema } from "./schemaTypes/CoFeedSchema.js";
 import { CoListSchema, CoreCoListSchema } from "./schemaTypes/CoListSchema.js";
-import {
-  CoMapSchema,
-  CoMapSchemaInit,
-  CoreCoMapSchema,
-} from "./schemaTypes/CoMapSchema.js";
+import { CoMapSchema, CoreCoMapSchema } from "./schemaTypes/CoMapSchema.js";
 import {
   CoOptionalSchema,
   CoreCoOptionalSchema,
@@ -84,8 +80,8 @@ export type CoValueSchemaFromCoreSchema<S extends CoreCoValueSchema> =
 export type CoValueClassFromAnySchema<S extends CoValueClassOrSchema> =
   S extends CoValueClass<any>
     ? S
-    : CoValueClass<InstanceOfSchema<S>> &
-        CoValueFromRaw<InstanceOfSchema<S>> &
+    : CoValueClass<NonNullable<InstanceOfSchema<S>>> &
+        CoValueFromRaw<NonNullable<InstanceOfSchema<S>>> &
         (S extends CoreAccountSchema ? AccountClassEssentials : {});
 
 type AccountClassEssentials = {
@@ -122,9 +118,3 @@ export type ResolveQueryStrict<
   T extends CoValueClassOrSchema,
   R extends ResolveQuery<T>,
 > = RefsToResolveStrict<NonNullable<InstanceOfSchemaCoValuesNullable<T>>, R>;
-
-export type InitFor<T extends CoValueClassOrSchema> = T extends CoreCoMapSchema<
-  infer Shape
->
-  ? Simplify<CoMapSchemaInit<Shape>>
-  : never;

package/src/tools/internal.ts

@@ -45,6 +45,7 @@ export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSc
 export * from "./implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchema.js";
 export * from "./implementation/zodSchema/typeConverters/InstanceOfSchemaCoValuesNullable.js";
+export * from "./implementation/zodSchema/typeConverters/CoFieldInit.js";
 export * from "./implementation/zodSchema/runtimeConverters/coValueSchemaTransformation.js";
 export * from "./implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.js";
 export * from "./coValues/extensions/imageDef.js";

package/src/tools/subscribe/SubscriptionScope.ts

@@ -7,7 +7,7 @@ import {
   type ID,
   type RefEncoded,
   type RefsToResolve,
-  instantiateRefEncoded,
+  instantiateRefEncodedFromRaw,
   isRefEncoded,
 } from "../internal.js";
 import { applyCoValueMigrations } from "../lib/migration.js";
@@ -75,7 +75,9 @@ export class SubscriptionScope<D extends CoValue> {
           }
 
           this.migrating = true;
-          applyCoValueMigrations(instantiateRefEncoded(this.schema, value));
+          applyCoValueMigrations(
+            instantiateRefEncodedFromRaw(this.schema, value),
+          );
           this.migrated = true;
           this.handleUpdate(lastUpdate);
           return;

package/src/tools/subscribe/utils.ts

@@ -4,7 +4,7 @@ import {
   CoValue,
   RefEncoded,
   coValueClassFromCoValueClassOrSchema,
-  instantiateRefEncoded,
+  instantiateRefEncodedFromRaw,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 import { SubscriptionScope } from "./SubscriptionScope.js";
@@ -26,7 +26,7 @@ export function createCoValue<D extends CoValue>(
   raw: RawCoValue,
   subscriptionScope: SubscriptionScope<D>,
 ) {
-  const freshValueInstance = instantiateRefEncoded(ref, raw);
+  const freshValueInstance = instantiateRefEncodedFromRaw(ref, raw);
 
   Object.defineProperty(freshValueInstance, "_subscriptionScope", {
     value: subscriptionScope,

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

@@ -52,6 +52,46 @@ describe("Simple CoFeed operations", async () => {
     expect(stream.perSession[me.sessionID]?.value).toEqual("milk");
   });
 
+  describe("Create CoFeed with a reference", () => {
+    let me: Account;
+
+    beforeEach(async () => {
+      await setupJazzTestSync();
+      me = await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+        creationProps: { name: "Hermes Puggington" },
+      });
+    });
+
+    test("using a CoValue", () => {
+      const Text = co.plainText();
+      const TextStream = co.feed(Text);
+
+      const stream = TextStream.create([Text.create("milk")], { owner: me });
+
+      const coValue = stream.perAccount[me.id]?.value;
+      expect(coValue?.toString()).toEqual("milk");
+    });
+
+    describe("using JSON", () => {
+      test("automatically creates CoValues for nested objects", () => {
+        const Text = co.plainText();
+        const TextStream = co.feed(Text);
+
+        const stream = TextStream.create(["milk"], { owner: me });
+
+        const coValue = stream.perAccount[me.id]?.value;
+        expect(coValue?.toString()).toEqual("milk");
+      });
+
+      test("can create a coPlainText from an empty string", () => {
+        const Schema = co.feed(co.plainText());
+        const feed = Schema.create([""]);
+        expect(feed.perAccount[me.id]?.value?.toString()).toBe("");
+      });
+    });
+  });
+
   test("Construction with nullable values", () => {
     const NullableTestStream = co.feed(z.string().nullable());
     const stream = NullableTestStream.create(["milk", null], { owner: me });

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

@@ -52,6 +52,48 @@ describe("Simple CoList operations", async () => {
     expect(list[2]).toBe("c");
   });
 
+  test("create CoList with reference using CoValue", () => {
+    const Dog = co.map({
+      name: z.string(),
+    });
+    const Person = co.map({
+      pets: co.list(Dog),
+    });
+
+    const person = Person.create({
+      pets: [Dog.create({ name: "Rex" }), Dog.create({ name: "Fido" })],
+    });
+
+    expect(person.pets.length).toEqual(2);
+    expect(person.pets[0]?.name).toEqual("Rex");
+    expect(person.pets[1]?.name).toEqual("Fido");
+  });
+
+  describe("create CoList with reference using JSON", () => {
+    test("automatically creates CoValues for nested objects", () => {
+      const Dog = co.map({
+        name: z.string(),
+      });
+      const Person = co.map({
+        pets: co.list(Dog),
+      });
+
+      const person = Person.create({
+        pets: [{ name: "Rex" }, { name: "Fido" }],
+      });
+
+      expect(person.pets.length).toEqual(2);
+      expect(person.pets[0]?.name).toEqual("Rex");
+      expect(person.pets[1]?.name).toEqual("Fido");
+    });
+
+    test("can create a coPlainText from an empty string", () => {
+      const Schema = co.list(co.plainText());
+      const list = Schema.create([""]);
+      expect(list[0]?.toString()).toBe("");
+    });
+  });
+
   test("list with nullable content", () => {
     const List = co.list(z.string().nullable());
     const list = List.create(["a", "b", "c", null]);

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

@@ -54,7 +54,7 @@ describe("CoMap", async () => {
       expectTypeOf(john._owner).toEqualTypeOf<Account | Group>();
     });
 
-    test("CoMap with reference", () => {
+    test("create CoMap with reference using CoValue", () => {
       const Dog = co.map({
         name: z.string(),
         breed: z.string(),
@@ -85,6 +85,46 @@ describe("CoMap", async () => {
       matches(person);
     });
 
+    test("create CoMap with reference using JSON", () => {
+      const Dog = co.map({
+        name: z.string(),
+        breed: z.string(),
+      });
+      const Person = co.map({
+        dog1: Dog,
+        dog2: Dog,
+        get friend() {
+          return Person.optional();
+        },
+      });
+
+      const person = Person.create({
+        // @ts-expect-error - breed is missing
+        dog1: { name: "Rex", items },
+        // @ts-expect-error - Object literal may only specify known properties
+        dog2: { name: "Fido", breed: "Labrador", extra: "extra" },
+        friend: {
+          dog1: {
+            name: "Rex",
+            breed: "Labrador",
+          },
+          dog2: { name: "Fido", breed: "Labrador" },
+        },
+      });
+
+      type ExpectedType = {
+        dog1: Loaded<typeof Dog>;
+        dog2: Loaded<typeof Dog>;
+        friend: Loaded<typeof Person> | undefined;
+      };
+
+      function matches(value: ExpectedType) {
+        return value;
+      }
+
+      matches(person);
+    });
+
     test("CoMap with optional reference", () => {
       const Dog = co.map({
         name: z.string(),

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

@@ -117,10 +117,9 @@ describe("CoMap", async () => {
       expect(emptyMap.color).toEqual(undefined);
     });
 
-    test("CoMap with reference", () => {
+    test("create CoMap with reference using CoValue", () => {
       const Dog = co.map({
         name: z.string(),
-        breed: z.string(),
       });
 
       const Person = co.map({
@@ -132,11 +131,89 @@ describe("CoMap", async () => {
       const person = Person.create({
         name: "John",
         age: 20,
-        dog: Dog.create({ name: "Rex", breed: "Labrador" }),
+        dog: Dog.create({ name: "Rex" }),
       });
 
       expect(person.dog?.name).toEqual("Rex");
-      expect(person.dog?.breed).toEqual("Labrador");
+    });
+
+    describe("create CoMap with references using JSON", () => {
+      const Dog = co.map({
+        type: z.literal("dog"),
+        name: z.string(),
+      });
+      const Cat = co.map({
+        type: z.literal("cat"),
+        name: z.string(),
+      });
+
+      const Person = co.map({
+        name: co.plainText(),
+        bio: co.richText(),
+        dog: Dog,
+        get friends() {
+          return co.list(Person);
+        },
+        reactions: co.feed(co.plainText()),
+        pet: co.discriminatedUnion("type", [Dog, Cat]),
+      });
+
+      let person: ReturnType<typeof Person.create>;
+
+      beforeEach(() => {
+        person = Person.create({
+          name: "John",
+          bio: "I am a software engineer",
+          dog: { type: "dog", name: "Rex" },
+          friends: [
+            {
+              name: "Jane",
+              bio: "I am a mechanical engineer",
+              dog: { type: "dog", name: "Fido" },
+              friends: [],
+              reactions: [],
+              pet: { type: "dog", name: "Fido" },
+            },
+          ],
+          reactions: ["👎", "👍"],
+          pet: { type: "cat", name: "Whiskers" },
+        });
+      });
+
+      it("automatically creates CoValues for each CoValue reference", () => {
+        expect(person.name.toString()).toEqual("John");
+        expect(person.bio.toString()).toEqual("I am a software engineer");
+        expect(person.dog?.name).toEqual("Rex");
+        expect(person.friends.length).toEqual(1);
+        expect(person.friends[0]?.name.toString()).toEqual("Jane");
+        expect(person.friends[0]?.bio.toString()).toEqual(
+          "I am a mechanical engineer",
+        );
+        expect(person.friends[0]?.dog.name).toEqual("Fido");
+        expect(person.friends[0]?.friends.length).toEqual(0);
+        expect(person.reactions.byMe?.value?.toString()).toEqual("👍");
+        expect(person.pet.name).toEqual("Whiskers");
+      });
+
+      it("creates a group for each new CoValue that is a child of the referencing CoValue's owner", () => {
+        for (const value of Object.values(person)) {
+          expect(
+            value._owner.getParentGroups().map((group: Group) => group.id),
+          ).toContain(person._owner.id);
+        }
+        const friend = person.friends[0]!;
+        for (const value of Object.values(friend)) {
+          expect(
+            value._owner.getParentGroups().map((group: Group) => group.id),
+          ).toContain(friend._owner.id);
+        }
+      });
+
+      it("can create a coPlainText from an empty string", () => {
+        const Schema = co.map({ text: co.plainText() });
+        const map = Schema.create({ text: "" });
+        expect(map.text.toString()).toBe("");
+      });
     });
 
     test("CoMap with self reference", () => {
@@ -209,7 +286,7 @@ describe("CoMap", async () => {
       const Person = co.map({
         name: z.string(),
         age: z.number(),
-        get friend(): co.Optional<typeof Person> {
+        get friend() {
           return co.optional(Person);
         },
       });

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

@@ -316,6 +316,60 @@ describe("Group inheritance", () => {
     expect(group.getRoleOf(bob.id)).toBe("reader");
     expect(group.getRoleOf(alice.id)).toBe(undefined);
   });
+
+  describe("when creating nested CoValues from a JSON object", () => {
+    const Task = co.plainText();
+    const Column = co.list(Task);
+    const Board = co.map({
+      title: z.string(),
+      columns: co.list(Column),
+    });
+
+    let board: ReturnType<typeof Board.create>;
+
+    beforeEach(async () => {
+      const me = co.account().getMe();
+      const writeAccess = Group.create();
+      writeAccess.addMember(me, "writer");
+
+      board = Board.create(
+        {
+          title: "My board",
+          columns: [
+            ["Task 1.1", "Task 1.2"],
+            ["Task 2.1", "Task 2.2"],
+          ],
+        },
+        writeAccess,
+      );
+    });
+
+    test("nested CoValues inherit permissions from the referencing CoValue", async () => {
+      const me = co.account().getMe();
+      const task = board.columns[0]![0]!;
+
+      const boardAsWriter = await Board.load(board.id, { loadAs: me });
+      expect(boardAsWriter?.title).toEqual("My board");
+      const taskAsWriter = await Task.load(task.id, { loadAs: me });
+      expect(taskAsWriter?.toString()).toEqual("Task 1.1");
+    });
+
+    test("nested CoValues inherit permissions from the referencing CoValue", async () => {
+      const me = co.account().getMe();
+      const reader = await co.account().createAs(me, {
+        creationProps: { name: "Reader" },
+      });
+
+      const task = board.columns[0]![0]!;
+      const taskGroup = task._owner.castAs(Group);
+      taskGroup.addMember(reader, "reader");
+
+      const taskAsReader = await Task.load(task.id, { loadAs: reader });
+      expect(taskAsReader?.toString()).toEqual("Task 1.1");
+      const boardAsReader = await Board.load(board.id, { loadAs: reader });
+      expect(boardAsReader).toBeNull();
+    });
+  });
 });
 
 describe("Group.getRoleOf", () => {