jazz-tools 0.14.19 → 0.14.21

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> jazz-tools@0.14.19 build /home/runner/_work/jazz/jazz/packages/jazz-tools
+> jazz-tools@0.14.21 build /home/runner/_work/jazz/jazz/packages/jazz-tools
 > tsup && pnpm types
 
 CLI Building entry: {"index":"src/index.ts","testing":"src/testing.ts"}
@@ -11,12 +11,12 @@
 ESM Build start
 ESM dist/index.js              11.11 KB
 ESM dist/testing.js            6.31 KB
-ESM dist/chunk-AA3SCYKI.js     133.47 KB
+ESM dist/chunk-DAOCWHIV.js     136.09 KB
 ESM dist/index.js.map          18.38 KB
 ESM dist/testing.js.map        12.57 KB
-ESM dist/chunk-AA3SCYKI.js.map 308.05 KB
-ESM ⚡️ Build success in 68ms
+ESM dist/chunk-DAOCWHIV.js.map 311.39 KB
+ESM ⚡️ Build success in 52ms
 
-> jazz-tools@0.14.19 types /home/runner/_work/jazz/jazz/packages/jazz-tools
+> jazz-tools@0.14.21 types /home/runner/_work/jazz/jazz/packages/jazz-tools
 > tsc --outDir dist
 

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # jazz-tools
 
+## 0.14.21
+
+### Patch Changes
+
+- e7e505e: Adds `makePublic(role)` alias for `group.addMember("everyone", role)`
+- 13b57aa: Fix creation of z.discriminatedUnions of CoValue schemas in Inbox and other places
+- 5662faa: Add `_createdAt` and `_lastUpdatedAt` getters for CoMaps
+- 2116a59: Improve SubscriptionScope.getCurrentValue to be the basis of the new React integration
+- Updated dependencies [c3d8779]
+  - cojson@0.14.21
+
+## 0.14.20
+
+### Patch Changes
+
+- 6f72419: Add support for per-CoMap migrations
+- 04b20c2: Make Zod schemas compatible with castAs
+  - cojson@0.14.20
+
 ## 0.14.19
 
 ### Patch Changes

package/dist/{chunk-AA3SCYKI.js → chunk-DAOCWHIV.js}

@@ -123,7 +123,8 @@ var CoValueBase = class {
     return this.toJSON();
   }
   /** @category Type Helpers */
-  castAs(cl) {
+  castAs(schema) {
+    const cl = "getCoSchema" in schema ? schema.getCoSchema() : schema;
     if (this.constructor === cl) {
       return this;
     }
@@ -150,6 +151,18 @@ var _CoMap = class _CoMap extends CoValueBase {
   get _schema() {
     return this.constructor._schema;
   }
+  /**
+   * The timestamp of the creation time of the CoMap
+   */
+  get _createdAt() {
+    return this._raw.earliestTxMadeAt ?? Number.MAX_SAFE_INTEGER;
+  }
+  /**
+   * The timestamp of the last updated time of the CoMap
+   */
+  get _lastUpdatedAt() {
+    return this._raw.latestTxMadeAt;
+  }
   /**
    * If property `prop` is a `coField.ref(...)`, you can use `coMaps._refs.prop` to access
    * the `Ref` instead of the potentially loaded/null value.
@@ -1933,6 +1946,17 @@ var _Group = class _Group extends CoValueBase {
       member === "everyone" ? member : member
     );
   }
+  /**
+   * Make the group public, so that everyone can read it.
+   * Alias for `addMember("everyone", role)`.
+   *
+   * @param role - Optional: the role to grant to everyone. Defaults to "reader".
+   * @returns The group itself.
+   */
+  makePublic(role = "reader") {
+    this.addMember("everyone", role);
+    return this;
+  }
   getParentGroups() {
     return this._raw.getParentGroups().map((group) => _Group.fromRaw(group));
   }
@@ -2710,6 +2734,19 @@ function instantiateRefEncoded(schema, raw) {
   ).fromRaw(raw);
 }
 
+// src/lib/migration.ts
+function applyCoValueMigrations(instance) {
+  const node = instance._raw.core.node;
+  const migratedCoValues = node._migratedCoValues ??= /* @__PURE__ */ new Set();
+  if ("migrate" in instance && typeof instance.migrate === "function" && instance._type !== "Account" && !migratedCoValues.has(instance.id)) {
+    migratedCoValues.add(instance.id);
+    const result = instance.migrate?.(instance);
+    if (result && "then" in result) {
+      throw new Error("Migration function cannot be async");
+    }
+  }
+}
+
 // src/subscribe/CoValueCoreSubscription.ts
 var CoValueCoreSubscription = class {
   constructor(node, id, listener) {
@@ -2838,6 +2875,8 @@ var SubscriptionScope = class _SubscriptionScope {
     this.autoloadedKeys = /* @__PURE__ */ new Set();
     this.skipInvalidKeys = /* @__PURE__ */ new Set();
     this.totalValidTransactions = 0;
+    this.migrated = false;
+    this.migrating = false;
     this.silenceUpdates = false;
     this.handleChildUpdate = (id, value, key) => {
       if (value.type === "unloaded") {
@@ -2863,7 +2902,19 @@ var SubscriptionScope = class _SubscriptionScope {
     this.subscribers = /* @__PURE__ */ new Set();
     this.resolve = resolve;
     this.value = { type: "unloaded", id };
+    let lastUpdate;
     this.subscription = new CoValueCoreSubscription(node, id, (value) => {
+      lastUpdate = value;
+      if (!this.migrated && value !== "unavailable") {
+        if (this.migrating) {
+          return;
+        }
+        this.migrating = true;
+        applyCoValueMigrations(instantiateRefEncoded(this.schema, value));
+        this.migrated = true;
+        this.handleUpdate(lastUpdate);
+        return;
+      }
       this.handleUpdate(value);
     });
   }
@@ -2971,9 +3022,21 @@ var SubscriptionScope = class _SubscriptionScope {
     return true;
   }
   getCurrentValue() {
-    if (!this.shouldSendUpdates()) return;
-    if (this.errorFromChildren) return this.errorFromChildren;
-    return this.value;
+    if (this.value.type === "unauthorized" || this.value.type === "unavailable") {
+      console.error(this.value.toString());
+      return null;
+    }
+    if (!this.shouldSendUpdates()) {
+      return void 0;
+    }
+    if (this.errorFromChildren) {
+      console.error(this.errorFromChildren.toString());
+      return null;
+    }
+    if (this.value.type === "loaded") {
+      return this.value.value;
+    }
+    return void 0;
   }
   triggerUpdate() {
     if (!this.shouldSendUpdates()) return;
@@ -3467,6 +3530,13 @@ function enrichCoMapSchema(schema) {
     },
     withHelpers: (helpers) => {
       return Object.assign(schema, helpers(schema));
+    },
+    withMigration: (migration) => {
+      coSchema.prototype.migrate = migration;
+      return enrichedSchema;
+    },
+    getCoSchema: () => {
+      return coSchema;
     }
   });
   const coSchema = zodSchemaToCoSchema2(enrichedSchema);
@@ -3478,6 +3548,44 @@ var coMapDefiner = (shape) => {
   });
   return enrichCoMapSchema(objectSchema);
 };
+function enrichAccountSchema(schema) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "Account",
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    createAs: (...args) => {
+      return coSchema.createAs(...args);
+    },
+    getMe: (...args) => {
+      return coSchema.getMe(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    fromRaw: (...args) => {
+      return coSchema.fromRaw(...args);
+    },
+    withMigration: (migration) => {
+      coSchema.prototype.migrate = async function(creationProps) {
+        await migration(this, creationProps);
+      };
+      return enrichedSchema;
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coAccountDefiner = (shape = {
   profile: coMapDefiner({
     name: z.string(),
@@ -3489,54 +3597,38 @@ var coAccountDefiner = (shape = {
   const objectSchema = z.object(shape).meta({
     collaborative: true
   });
-  const accountSchema = objectSchema;
-  accountSchema.collaborative = true;
-  accountSchema.builtin = "Account";
-  accountSchema.create = function(...args) {
-    return zodSchemaToCoSchema2(this).create(...args);
-  };
-  accountSchema.createAs = function(...args) {
-    return zodSchemaToCoSchema2(this).createAs(...args);
-  };
-  accountSchema.getMe = function() {
-    return zodSchemaToCoSchema2(this).getMe();
-  };
-  accountSchema.load = function(...args) {
-    return zodSchemaToCoSchema2(this).load(...args);
-  };
-  accountSchema.subscribe = function(...args) {
-    return zodSchemaToCoSchema2(this).subscribe(...args);
-  };
-  accountSchema.withHelpers = function(helpers) {
-    return { ...this, ...helpers };
-  };
-  accountSchema.withMigration = function(migration) {
-    return Object.assign(this, { migration });
-  };
-  return accountSchema;
+  return enrichAccountSchema(objectSchema);
 };
 var coRecordDefiner = (_keyType, valueType) => {
   return coMapDefiner({}).catchall(valueType);
 };
+function enrichCoListSchema(schema) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coListDefiner = (element) => {
   const arraySchema = z.array(element).meta({
     collaborative: true
   });
-  const coListSchema = arraySchema;
-  coListSchema.collaborative = true;
-  coListSchema.create = function(...args) {
-    return zodSchemaToCoSchema2(this).create(...args);
-  };
-  coListSchema.load = function(...args) {
-    return zodSchemaToCoSchema2(this).load(...args);
-  };
-  coListSchema.subscribe = function(...args) {
-    return zodSchemaToCoSchema2(this).subscribe(...args);
-  };
-  coListSchema.withHelpers = function(helpers) {
-    return Object.assign(this, helpers(this));
-  };
-  return coListSchema;
+  return enrichCoListSchema(arraySchema);
 };
 var coProfileDefiner = (shape = {}) => {
   const ehnancedShape = Object.assign(shape ?? {}, {
@@ -3546,79 +3638,110 @@ var coProfileDefiner = (shape = {}) => {
   });
   return coMapDefiner(ehnancedShape);
 };
+function enrichCoFeedSchema(schema, element) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoFeed",
+    element,
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coFeedDefiner = (element) => {
-  const placeholderSchema = z.instanceof(CoFeed);
-  const coFeedSchema = placeholderSchema;
-  coFeedSchema.collaborative = true;
-  coFeedSchema.builtin = "CoFeed";
-  coFeedSchema.element = element;
-  coFeedSchema.create = function(...args) {
-    return zodSchemaToCoSchema2(this).create(...args);
-  };
-  coFeedSchema.load = function(...args) {
-    return zodSchemaToCoSchema2(this).load(...args);
-  };
-  coFeedSchema.subscribe = function(...args) {
-    return zodSchemaToCoSchema2(this).subscribe(...args);
-  };
-  return coFeedSchema;
+  return enrichCoFeedSchema(z.instanceof(CoFeed), element);
 };
+function enrichFileStreamSchema(schema) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "FileStream",
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    createFromBlob: (...args) => {
+      return coSchema.createFromBlob(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    loadAsBlob: (...args) => {
+      return coSchema.loadAsBlob(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coFileStreamDefiner = () => {
-  const placeholderSchema = z.instanceof(FileStream);
-  const fileStreamSchema = placeholderSchema;
-  fileStreamSchema.collaborative = true;
-  fileStreamSchema.builtin = "FileStream";
-  fileStreamSchema.create = function(options) {
-    return FileStream.create(options);
-  };
-  fileStreamSchema.createFromBlob = function(blob, options) {
-    return FileStream.createFromBlob(blob, options);
-  };
-  fileStreamSchema.load = function(id, options) {
-    return FileStream.load(id, options);
-  };
-  fileStreamSchema.loadAsBlob = function(id, options) {
-    return FileStream.loadAsBlob(id, options);
-  };
-  fileStreamSchema.subscribe = function(id, options, listener) {
-    return FileStream.subscribe(id, options, listener);
-  };
-  return fileStreamSchema;
+  return enrichFileStreamSchema(z.instanceof(FileStream));
 };
+function enrichPlainTextSchema(schema) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoPlainText",
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    fromRaw: (...args) => {
+      return coSchema.fromRaw(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coPlainTextDefiner = () => {
-  const placeholderSchema = z.instanceof(CoPlainText);
-  const plainTextSchema = placeholderSchema;
-  plainTextSchema.collaborative = true;
-  plainTextSchema.builtin = "CoPlainText";
-  plainTextSchema.create = function(...args) {
-    return CoPlainText.create(...args);
-  };
-  plainTextSchema.load = function(...args) {
-    return CoPlainText.load(...args);
-  };
-  plainTextSchema.subscribe = function(...args) {
-    return CoPlainText.subscribe(...args);
-  };
-  plainTextSchema.fromRaw = function(...args) {
-    return CoPlainText.fromRaw(...args);
-  };
-  return plainTextSchema;
+  return enrichPlainTextSchema(z.instanceof(CoPlainText));
 };
+function enrichRichTextSchema(schema) {
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    builtin: "CoRichText",
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    getCoSchema: () => {
+      return coSchema;
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coRichTextDefiner = () => {
-  const placeholderSchema = z.instanceof(CoRichText);
-  const richTextSchema = placeholderSchema;
-  richTextSchema.collaborative = true;
-  richTextSchema.builtin = "CoRichText";
-  richTextSchema.create = function(...args) {
-    return CoRichText.create(...args);
-  };
-  richTextSchema.load = function(...args) {
-    return CoRichText.load(...args);
-  };
-  richTextSchema.subscribe = function(...args) {
-    return CoRichText.subscribe(...args);
-  };
-  return richTextSchema;
+  return enrichRichTextSchema(z.instanceof(CoRichText));
 };
 var coImageDefiner = () => {
   return ImageDefinition;
@@ -3865,15 +3988,6 @@ function tryZodSchemaToCoSchema(schema) {
           }
         }
       };
-      if ("migration" in schema) {
-        const migration = schema.migration;
-        if (typeof migration !== "function") {
-          throw new Error("migration must be a function");
-        }
-        coSchema.prototype.migrate = async function(creationProps) {
-          await migration(this, creationProps);
-        };
-      }
       coSchemasForZodSchemas.set(schema, coSchema);
       return coSchema;
     } else if (isZodArray(schema)) {
@@ -3941,9 +4055,18 @@ function zodSchemaToCoSchema2(schema) {
 function anySchemaToCoSchema(schema) {
   if (isCoValueClass(schema)) {
     return schema;
-  } else {
-    return zodSchemaToCoSchema2(schema);
+  } else if ("getCoSchema" in schema) {
+    return schema.getCoSchema();
+  } else if ("def" in schema) {
+    const coSchema = tryZodSchemaToCoSchema(schema);
+    if (!coSchema) {
+      throw new Error(
+        `Unsupported zod type: ${schema.def?.type || JSON.stringify(schema)}`
+      );
+    }
+    return coSchema;
   }
+  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
 }
 function zodSchemaToCoSchemaOrKeepPrimitive(schema) {
   const coSchema = tryZodSchemaToCoSchema(schema);
@@ -4611,9 +4734,9 @@ function isAccountInstance(instance) {
   return "_type" in instance && instance._type === "Account";
 }
 function parseCoValueCreateOptions(options) {
-  const Group4 = RegisteredSchemas["Group"];
+  const Group3 = RegisteredSchemas["Group"];
   if (!options) {
-    return { owner: Group4.create(), uniqueness: void 0 };
+    return { owner: Group3.create(), uniqueness: void 0 };
   }
   if ("_type" in options) {
     if (options._type === "Account" || options._type === "Group") {
@@ -4622,7 +4745,7 @@ function parseCoValueCreateOptions(options) {
   }
   const uniqueness = options.unique ? { uniqueness: options.unique } : void 0;
   return {
-    owner: options.owner ?? Group4.create(),
+    owner: options.owner ?? Group3.create(),
     uniqueness
   };
 }
@@ -4672,4 +4795,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-AA3SCYKI.js.map
+//# sourceMappingURL=chunk-DAOCWHIV.js.map