jazz-tools 0.18.28 → 0.18.30

package/src/svelte/tests/media/image.svelte.test.ts

@@ -104,6 +104,91 @@ describe("Image", async () => {
       expect(img!.src).toBe(placeholderDataUrl);
     });
 
+    it("should not override actual placeholders", async () => {
+      const placeholderDataUrl =
+        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+      const customPlaceholder =
+        "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLXVzZXItaWNvbiBsdWNpZGUtdXNlciI+PHBhdGggZD0iTTE5IDIxdi0yYTQgNCAwIDAgMC00LTRIOWE0IDQgMCAwIDAtNCA0djIiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjciIHI9IjQiLz48L3N2Zz4=";
+
+      const original = FileStream.create({ owner: account });
+      original.start({ mimeType: "image/jpeg" });
+      // Don't end original, so it has no chunks
+
+      const im = ImageDefinition.create(
+        {
+          original,
+          originalSize: [100, 100],
+          progressive: false,
+          placeholderDataURL: placeholderDataUrl,
+        },
+        {
+          owner: account,
+        },
+      );
+
+      const { container } = renderWithAccount({
+        imageId: im.$jazz.id,
+        alt: "test",
+        placeholder: customPlaceholder
+      });
+
+      const img = container.querySelector("img");
+      expect(img).toBeDefined();
+      expect(img!.src).toBe(placeholderDataUrl);
+    });
+
+    it("should show custom placeholder while loading and replace with loaded image", async () => {
+      const createObjectURLSpy = vi
+        .spyOn(URL, "createObjectURL")
+        .mockImplementation((blob) => {
+          if (!(blob instanceof Blob)) {
+            throw new Error("Blob expected");
+          }
+          return `blob:test-${blob.size}`;
+        });
+
+      const customPlaceholder =
+        "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLXVzZXItaWNvbiBsdWNpZGUtdXNlciI+PHBhdGggZD0iTTE5IDIxdi0yYTQgNCAwIDAgMC00LTRIOWE0IDQgMCAwIDAtNCA0djIiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjciIHI9IjQiLz48L3N2Zz4=";
+
+      // Create an image with no chunks initially (loading state)
+      const original = FileStream.create({ owner: account });
+      original.start({ mimeType: "image/jpeg" });
+      // Don't end original, so it has no chunks
+
+      const im = ImageDefinition.create(
+        {
+          original,
+          originalSize: [100, 100],
+          progressive: false,
+        },
+        {
+          owner: account,
+        },
+      );
+
+      const { container } = renderWithAccount({
+        imageId: im.$jazz.id,
+        alt: "test-loading-custom-placeholder",
+        placeholder: customPlaceholder
+      });
+      // Initially should show custom placeholder
+      let img = container.querySelector("img");
+      expect(img).toBeDefined();
+      expect(img!.src).toBe(customPlaceholder);
+
+      // Now add the actual image data
+      const imageData = await createDummyFileStream(100, account);
+      im.$jazz.set("100x100", imageData);
+
+      // Wait for the image to load and replace the placeholder
+      await waitFor(() => {
+        img = container.querySelector("img");
+        expect(img!.src).toBe("blob:test-100");
+      });
+
+      expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+    });
+
     it("should render the original image once loaded", async () => {
       const createObjectURLSpy = vi
         .spyOn(URL, "createObjectURL")

package/src/tools/coValues/account.ts

@@ -12,6 +12,7 @@ import {
   RawCoValue,
   SessionID,
   cojsonInternals,
+  isAccountRole,
 } from "cojson";
 import {
   AnonymousJazzAgent,
@@ -166,29 +167,52 @@ export class Account extends CoValueBase implements CoValue {
     }
     const role = valueOwner.getRoleOf(this.$jazz.id);
 
+    return isAccountRole(role);
+  }
+
+  canWrite(value: CoValue): boolean {
+    const valueOwner = value.$jazz.owner;
+    if (!valueOwner) {
+      if (value[TypeSym] === "Group") {
+        const roleInGroup = (value as Group).getRoleOf(this.$jazz.id);
+        return (
+          roleInGroup === "admin" ||
+          roleInGroup === "manager" ||
+          roleInGroup === "writer"
+        );
+      }
+      if (value[TypeSym] === "Account") {
+        return value.$jazz.id === this.$jazz.id;
+      }
+      return false;
+    }
+    const role = valueOwner.getRoleOf(this.$jazz.id);
+
     return (
       role === "admin" ||
+      role === "manager" ||
       role === "writer" ||
-      role === "reader" ||
       role === "writeOnly"
     );
   }
 
-  canWrite(value: CoValue): boolean {
+  canManage(value: CoValue): boolean {
     const valueOwner = value.$jazz.owner;
     if (!valueOwner) {
       if (value[TypeSym] === "Group") {
         const roleInGroup = (value as Group).getRoleOf(this.$jazz.id);
-        return roleInGroup === "admin" || roleInGroup === "writer";
+        return roleInGroup === "manager" || roleInGroup === "admin";
       }
       if (value[TypeSym] === "Account") {
         return value.$jazz.id === this.$jazz.id;
       }
       return false;
     }
-    const role = valueOwner.getRoleOf(this.$jazz.id);
 
-    return role === "admin" || role === "writer" || role === "writeOnly";
+    return (
+      valueOwner.getRoleOf(this.$jazz.id) === "admin" ||
+      valueOwner.getRoleOf(this.$jazz.id) === "manager"
+    );
   }
 
   canAdmin(value: CoValue): boolean {
@@ -203,6 +227,7 @@ export class Account extends CoValueBase implements CoValue {
       }
       return false;
     }
+
     return valueOwner.getRoleOf(this.$jazz.id) === "admin";
   }
 

package/src/tools/coValues/coList.ts

@@ -22,7 +22,7 @@ import {
   TypeSym,
   BranchDefinition,
   getIdFromHeader,
-  unstable_loadUnique,
+  internalLoadUnique,
 } from "../internal.js";
 import {
   AnonymousJazzAgent,
@@ -380,7 +380,7 @@ export class CoList<out Item = any>
       options.owner.$jazz.id,
     );
 
-    return unstable_loadUnique(this, {
+    return internalLoadUnique(this, {
       header,
       owner: options.owner,
       resolve: options.resolve,
@@ -423,7 +423,7 @@ export class CoList<out Item = any>
 
     if (!owner) return owner;
 
-    return unstable_loadUnique(this, {
+    return internalLoadUnique(this, {
       header,
       owner,
       resolve: options?.resolve,

package/src/tools/coValues/coMap.ts

@@ -29,7 +29,7 @@ import {
   TypeSym,
   BranchDefinition,
   getIdFromHeader,
-  unstable_loadUnique,
+  internalLoadUnique,
 } from "../internal.js";
 import {
   Account,
@@ -499,7 +499,7 @@ export class CoMap extends CoValueBase implements CoValue {
       options.owner.$jazz.id,
     );
 
-    return unstable_loadUnique(this, {
+    return internalLoadUnique(this, {
       header,
       owner: options.owner,
       resolve: options.resolve,
@@ -544,7 +544,7 @@ export class CoMap extends CoValueBase implements CoValue {
 
     if (!owner) return owner;
 
-    return unstable_loadUnique(this, {
+    return internalLoadUnique(this, {
       header,
       owner,
       resolve: options?.resolve,

package/src/tools/coValues/group.ts

@@ -1,5 +1,6 @@
 import {
   RawAccount,
+  isAccountRole,
   type AccountRole,
   type AgentID,
   type Everyone,
@@ -10,7 +11,6 @@ import {
 } from "cojson";
 import {
   AnonymousJazzAgent,
-  BranchDefinition,
   CoValue,
   CoValueClass,
   ID,
@@ -108,13 +108,16 @@ export class Group extends CoValueBase implements CoValue {
    */
   addMember(
     member: Group,
-    role?: "reader" | "writer" | "admin" | "inherit",
+    role?: "reader" | "writer" | "admin" | "manager" | "inherit",
+  ): void;
+  addMember(
+    member: Group | Account,
+    role: "reader" | "writer" | "admin" | "manager",
   ): void;
-  addMember(member: Group | Account, role: "reader" | "writer" | "admin"): void;
   addMember(
     member: Group | Everyone | Account,
     role?: AccountRole | "inherit",
-  ) {
+  ): void {
     if (isGroupValue(member)) {
       if (role === "writeOnly")
         throw new Error("Cannot add group as member with write-only role");
@@ -158,12 +161,7 @@ export class Group extends CoValueBase implements CoValue {
 
       const role = this.$jazz.raw.roleOf(accountID);
 
-      if (
-        role === "admin" ||
-        role === "writer" ||
-        role === "reader" ||
-        role === "writeOnly"
-      ) {
+      if (isAccountRole(role)) {
         const ref = new Ref<Account>(
           accountID,
           this.$jazz.loadedAs,
@@ -249,9 +247,12 @@ export class Group extends CoValueBase implements CoValue {
    */
   extend(
     parent: Group,
-    roleMapping?: "reader" | "writer" | "admin" | "inherit",
+    roleMapping?: "reader" | "writer" | "admin" | "manager" | "inherit",
   ): this {
-    this.$jazz.raw.extend(parent.$jazz.raw, roleMapping);
+    this.$jazz.raw.extend(
+      parent.$jazz.raw,
+      roleMapping as "reader" | "writer" | "admin" | "manager" | "inherit",
+    );
     return this;
   }
 

package/src/tools/coValues/inbox.ts

@@ -431,12 +431,12 @@ export class InboxSender<I extends CoValue, O extends CoValue | undefined> {
       throw new Error("Failed to load the inbox owner profile");
     }
 
+    const inboxOwnerRole = inboxOwnerProfileRaw.group.roleOf(
+      currentAccount.$jazz.raw.id,
+    );
+
     if (
-      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !==
-        "reader" &&
-      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !==
-        "writer" &&
-      inboxOwnerProfileRaw.group.roleOf(currentAccount.$jazz.raw.id) !== "admin"
+      !["reader", "writer", "admin", "manager"].includes(inboxOwnerRole ?? "")
     ) {
       throw new Error(
         "Insufficient permissions to access the inbox, make sure its user profile is publicly readable.",

package/src/tools/coValues/interfaces.ts

@@ -461,6 +461,41 @@ export function getIdFromHeader(
 }
 
 export async function unstable_loadUnique<
+  S extends CoValueClassOrSchema,
+  const R extends ResolveQuery<S>,
+>(
+  schema: S,
+  options: {
+    unique: CoValueUniqueness["uniqueness"];
+    onCreateWhenMissing?: () => void;
+    onUpdateWhenFound?: (value: Loaded<S, R>) => void;
+    owner: Account | Group;
+    resolve?: ResolveQueryStrict<S, R>;
+  },
+): Promise<Loaded<S, R> | null> {
+  const cls = coValueClassFromCoValueClassOrSchema(schema);
+
+  if (
+    !("_getUniqueHeader" in cls) ||
+    typeof cls._getUniqueHeader !== "function"
+  ) {
+    throw new Error("CoValue class does not support unique headers");
+  }
+
+  const header = cls._getUniqueHeader(options.unique, options.owner.$jazz.id);
+
+  return internalLoadUnique(cls, {
+    header,
+    onCreateWhenMissing: options.onCreateWhenMissing,
+    // @ts-expect-error loaded is not compatible with Resolved at type level, but they are the same thing
+    onUpdateWhenFound: options.onUpdateWhenFound,
+    owner: options.owner,
+    // @ts-expect-error loaded is not compatible with Resolved at type level, but they are the same thing
+    resolve: options.resolve,
+  }) as unknown as Loaded<S, R> | null;
+}
+
+export async function internalLoadUnique<
   V extends CoValue,
   R extends RefsToResolve<V>,
 >(
@@ -484,32 +519,28 @@ export async function unstable_loadUnique<
   // retrying failures
   // This way when we want to upsert we are sure that, if the load failed
   // it failed because the unique value was missing
-  let result = await loadCoValueWithoutMe(cls, id, {
+  await loadCoValueWithoutMe(cls, id, {
     skipRetry: true,
     loadAs,
   });
 
-  if (options.onCreateWhenMissing) {
-    // if load returns unavailable, we check the state in localNode
-    // to ward against race conditions that would happen when
-    // running the same upsert unique concurrently
-    if (!result && node.getCoValue(id).hasVerifiedContent()) {
-      result = await loadCoValueWithoutMe(cls, id, {
-        loadAs,
-      });
-    }
+  const isAvailable = node.getCoValue(id).hasVerifiedContent();
 
-    if (!result) {
-      options.onCreateWhenMissing();
+  // if load returns unavailable, we check the state in localNode
+  // to ward against race conditions that would happen when
+  // running the same upsert unique concurrently
+  if (options.onCreateWhenMissing && !isAvailable) {
+    options.onCreateWhenMissing();
 
-      return loadCoValueWithoutMe(cls, id, {
-        loadAs,
-        resolve: options.resolve,
-      });
-    }
+    return loadCoValueWithoutMe(cls, id, {
+      loadAs,
+      resolve: options.resolve,
+    });
   }
 
-  if (!result) return result;
+  if (!isAvailable) {
+    return null;
+  }
 
   if (options.onUpdateWhenFound) {
     // we deeply load the value, retrying any failures

package/src/tools/exports.ts

@@ -36,7 +36,6 @@ export type {
   AccountClass,
   AccountCreationProps,
   BaseProfileShape,
-  unstable_loadUnique,
 } from "./internal.js";
 
 export {
@@ -57,6 +56,7 @@ export {
   exportCoValue,
   importContentPieces,
   Ref,
+  unstable_loadUnique,
 } from "./internal.js";
 
 export {

package/src/tools/implementation/invites.ts

@@ -1,16 +1,11 @@
-import { type InviteSecret, cojsonInternals } from "cojson";
+import { AccountRole, type InviteSecret, cojsonInternals } from "cojson";
 import { Account } from "../coValues/account.js";
-import type {
-  CoValue,
-  CoValueClass,
-  CoValueClassOrSchema,
-  ID,
-} from "../internal.js";
+import type { CoValue, CoValueClassOrSchema } from "../internal.js";
 
 /** @category Invite Links */
 export function createInviteLink<C extends CoValue>(
   value: C,
-  role: "reader" | "writer" | "admin" | "writeOnly",
+  role: AccountRole,
   baseURL: string,
   valueHint?: string,
 ): string {

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

@@ -26,7 +26,9 @@ export type SchemaField =
   | z.core.$ZodNullable<z.core.$ZodType>
   | z.core.$ZodUnion<z.core.$ZodType[]>
   | z.core.$ZodDiscriminatedUnion<z.core.$ZodType[]>
+  | z.core.$ZodIntersection<z.core.$ZodType, z.core.$ZodType>
   | z.core.$ZodObject<z.core.$ZodLooseShape>
+  | z.core.$ZodRecord<z.core.$ZodRecordKey, z.core.$ZodType>
   | z.core.$ZodArray<z.core.$ZodType>
   | z.core.$ZodTuple<z.core.$ZodType[]>
   | z.core.$ZodReadonly<z.core.$ZodType>
@@ -146,8 +148,10 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
         );
       } else if (
         zodSchemaDef.type === "object" ||
+        zodSchemaDef.type === "record" ||
         zodSchemaDef.type === "array" ||
-        zodSchemaDef.type === "tuple"
+        zodSchemaDef.type === "tuple" ||
+        zodSchemaDef.type === "intersection"
       ) {
         return coField.json();
       } else if (zodSchemaDef.type === "union") {

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

@@ -2,6 +2,7 @@ import {
   Account,
   AccountCreationProps,
   BranchDefinition,
+  coOptionalDefiner,
   Group,
   RefsToResolveStrict,
   Simplify,
@@ -149,6 +150,7 @@ export function enrichAccountSchema<Shape extends BaseAccountShape>(
     getCoValueClass: () => {
       return coValueClass;
     },
+    optional: () => coOptionalDefiner(enrichedSchema),
   }) as unknown as AccountSchema<Shape>;
   return enrichedSchema;
 }

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

@@ -25,59 +25,72 @@ export type TypeOfZodSchema<S extends z.core.$ZodType> =
               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[]
+          : S extends z.core.$ZodIntersection<
+                infer Left extends z.core.$ZodType,
+                infer Right extends z.core.$ZodType
+              >
+            ? TypeOfZodSchema<Left> & TypeOfZodSchema<Right>
+            : 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.$ZodRecord<
+                    infer Key,
+                    infer Value extends z.core.$ZodType
                   >
                 ? {
-                    [key in keyof Items]: TypeOfZodSchema<Items[key]>;
+                    [key in z.output<Key>]: TypeOfZodSchema<Value>;
                   }
-                : 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
+                : 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
                                     >
-                                  ? TypeOfZodSchema<Default>
-                                  : S extends z.core.$ZodCodec<
-                                        any,
-                                        infer Out extends z.core.$ZodType
+                                  ? pattern
+                                  : S extends z.core.$ZodReadonly<
+                                        infer Inner extends z.core.$ZodType
                                       >
-                                    ? Out["_zod"]["output"]
-                                    : S extends z.core.$ZodCatch<
-                                          infer Catch extends z.core.$ZodType
+                                    ? TypeOfZodSchema<Inner>
+                                    : S extends z.core.$ZodDefault<
+                                          infer Default extends z.core.$ZodType
                                         >
-                                      ? TypeOfZodSchema<Catch>
-                                      : never;
+                                      ? TypeOfZodSchema<Default>
+                                      : S extends z.core.$ZodCodec<
+                                            any,
+                                            infer Out extends z.core.$ZodType
+                                          >
+                                        ? Out["_zod"]["output"]
+                                        : S extends z.core.$ZodCatch<
+                                              infer Catch extends
+                                                z.core.$ZodType
+                                            >
+                                          ? TypeOfZodSchema<Catch>
+                                          : never;

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

@@ -32,8 +32,8 @@ export {
   int32,
   union,
   discriminatedUnion,
-  // record,
-  // intersection,
+  record,
+  intersection,
   int,
   codec,
   optional,

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -220,6 +220,9 @@ export class CoValueCoreSubscription {
 
   emit(value: RawCoValue | "unavailable"): void {
     if (this.unsubscribed) return;
+    if (!isReadyForEmit(value)) {
+      return;
+    }
 
     this.listener(value);
   }
@@ -234,3 +237,17 @@ export class CoValueCoreSubscription {
     this._unsubscribe();
   }
 }
+
+/**
+ * This is true if the value is unavailable, or if the value is a binary coValue or a completely downloaded coValue.
+ */
+function isReadyForEmit(value: RawCoValue | "unavailable") {
+  if (value === "unavailable") {
+    return true;
+  }
+
+  return (
+    value.core.verified?.header.meta?.type === "binary" ||
+    value.core.isCompletelyDownloaded()
+  );
+}