making calendar tutorial

packages/runner/src/cell.ts

@@ -24,7 +24,11 @@ import { diffAndUpdate } from "./data-updating.ts";
 import { resolveLink } from "./link-resolution.ts";
 import { ignoreReadForScheduling, txToReactivityLog } from "./scheduler.ts";
 import { type Cancel, isCancel, useCancelGroup } from "./cancel.ts";
-import { validateAndTransform } from "./schema.ts";
+import {
+  processDefaultValue,
+  resolveSchema,
+  validateAndTransform,
+} from "./schema.ts";
 import { toURI } from "./uri-utils.ts";
 import {
   type LegacyJSONCellLink,
@@ -448,6 +452,9 @@ export class RegularCell<T> implements Cell<T> {
     // retry on conflict.
     if (!this.synced) this.sync();
 
+    // Looks for arrays and makes sure each object gets its own doc.
+    newValue = recursivelyAddIDIfNeeded(newValue);
+
     // TODO(@ubik2) investigate whether i need to check classified as i walk down my own obj
     diffAndUpdate(
       this.runtime,
@@ -486,36 +493,37 @@ export class RegularCell<T> implements Cell<T> {
     const resolvedLink = resolveLink(this.tx, this.link);
     const currentValue = this.tx.readValueOrThrow(resolvedLink);
 
-    // If there's no current value, initialize based on schema
+    // If there's no current value, initialize based on schema, even if there is
+    // no default value.
     if (currentValue === undefined) {
-      if (isObject(this.schema)) {
-        // Check if schema allows objects
-        const allowsObject = ContextualFlowControl.isTrueSchema(this.schema) ||
-          this.schema.type === "object" ||
-          (Array.isArray(this.schema.type) &&
-            this.schema.type.includes("object")) ||
-          (this.schema.anyOf &&
-            this.schema.anyOf.some((s) =>
-              typeof s === "object" && s.type === "object"
-            ));
-
-        if (!allowsObject) {
-          throw new Error(
-            "Cannot update with object value - schema does not allow objects",
-          );
-        }
-      } else if (this.schema === false) {
+      const resolvedSchema = resolveSchema(this.schema, this.rootSchema);
+
+      // TODO(seefeld,ubik2): This should all be moved to schema helpers. This
+      // just wants to know whether the value could be an object.
+      const allowsObject = resolvedSchema === undefined ||
+        ContextualFlowControl.isTrueSchema(resolvedSchema) ||
+        (isObject(resolvedSchema) &&
+          (resolvedSchema.type === "object" ||
+            (Array.isArray(resolvedSchema.type) &&
+              resolvedSchema.type.includes("object")) ||
+            (resolvedSchema.anyOf &&
+              resolvedSchema.anyOf.some((s) =>
+                typeof s === "object" && s.type === "object"
+              ))));
+
+      if (!allowsObject) {
         throw new Error(
           "Cannot update with object value - schema does not allow objects",
         );
       }
+
       this.tx.writeValueOrThrow(resolvedLink, {});
     }
 
     // Now update each property
     for (const [key, value] of Object.entries(values)) {
       // Workaround for type checking, since T can be Cell<> and that's fine.
-      (this.key as any)(key).set(value);
+      (this.key as any)(key).set(recursivelyAddIDIfNeeded(value));
     }
   }
 
@@ -546,14 +554,6 @@ export class RegularCell<T> implements Cell<T> {
       throw new Error("Can't push into non-array value");
     }
 
-    // If this is an object and it doesn't have an ID, add one.
-    const valuesToWrite = value.map((val: any) =>
-      (!isLink(val) && isObject(val) &&
-          (val as { [ID]?: unknown })[ID] === undefined && getTopFrame())
-        ? { [ID]: getTopFrame()!.generatedIdCounter++, ...val }
-        : val
-    );
-
     // If there is no array yet, create it first. We have to do this as a
     // separate operation, so that in the next steps [ID] is properly anchored
     // in the array.
@@ -565,8 +565,14 @@ export class RegularCell<T> implements Cell<T> {
         [],
         cause,
       );
-      array = isObject(this.schema) && Array.isArray(this.schema?.default)
-        ? this.schema.default
+      const resolvedSchema = resolveSchema(this.schema, this.rootSchema);
+      array = isObject(resolvedSchema) && Array.isArray(resolvedSchema?.default)
+        ? processDefaultValue(
+          this.runtime,
+          this.tx,
+          this.link,
+          resolvedSchema.default,
+        )
         : [];
     }
 
@@ -575,7 +581,7 @@ export class RegularCell<T> implements Cell<T> {
       this.runtime,
       this.tx,
       resolvedLink,
-      [...array, ...valuesToWrite],
+      recursivelyAddIDIfNeeded([...array, ...value]),
       cause,
     );
   }
@@ -877,6 +883,78 @@ function subscribeToReferencedDocs<T>(
   };
 }
 
+/**
+ * Recursively adds IDs elements in arrays, unless they are already a link.
+ *
+ * This ensures that mutable arrays only consist of links to documents, at least
+ * when written to only via .set, .update and .push above.
+ *
+ * TODO(seefeld): When an array has default entries and is rewritten as [...old,
+ * new], this will still break, because the previous entries will point back to
+ * the array itself instead of being new entries.
+ *
+ * @param value - The value to add IDs to.
+ * @returns The value with IDs added.
+ */
+function recursivelyAddIDIfNeeded<T>(
+  value: T,
+  seen: Map<unknown, unknown> = new Map(),
+): T {
+  // Can't add IDs without top frame.
+  if (!getTopFrame()) return value;
+
+  // Already a link, no need to add IDs. Not a record, no need to add IDs.
+  if (!isRecord(value) || isLink(value)) return value;
+
+  // Already seen, return previously annotated result.
+  if (seen.has(value)) return seen.get(value) as T;
+
+  if (Array.isArray(value)) {
+    const result: unknown[] = [];
+
+    // Set before traversing, otherwise we'll infinite recurse.
+    seen.set(value, result);
+
+    result.push(...value.map((v) => {
+      const value = recursivelyAddIDIfNeeded(v, seen);
+      // For objects on arrays only: Add ID if not already present.
+      if (
+        isObject(value) && !isLink(value) && !(ID in value)
+      ) {
+        return { [ID]: getTopFrame()!.generatedIdCounter++, ...value };
+      } else {
+        return value;
+      }
+    }));
+    return result as T;
+  } else {
+    const result: Record<string, unknown> = {};
+
+    // Set before traversing, otherwise we'll infinite recurse.
+    seen.set(value, result);
+
+    Object.entries(value).forEach(([key, v]) => {
+      result[key] = recursivelyAddIDIfNeeded(v, seen);
+    });
+
+    // Copy supported symbols from original value.
+    if (ID in value) {
+      (result as { [ID]: unknown })[ID] = value[ID];
+    }
+    if (ID_FIELD in value) {
+      (result as { [ID_FIELD]: unknown })[ID_FIELD] = value[ID_FIELD];
+    }
+
+    return result as T;
+  }
+}
+
+/**
+ * Converts cells and objects that can be turned to cells to links.
+ *
+ * @param value - The value to convert.
+ * @returns The converted value.
+ */
 export function convertCellsToLinks(
   value: readonly any[] | Record<string, any> | any,
   path: string[] = [],

packages/runner/src/data-updating.ts

@@ -24,6 +24,11 @@ import {
 import { type IRuntime } from "./runtime.ts";
 import { toURI } from "./uri-utils.ts";
 
+const diffLogger = getLogger("normalizeAndDiff", {
+  enabled: false,
+  level: "debug",
+});
+
 /**
  * Traverses newValue and updates `current` and any relevant linked documents.
  *
@@ -86,34 +91,6 @@ type ChangeSet = {
  * @param context - The context of the change.
  * @returns An array of changes that should be written.
  */
-const diffLogger = getLogger("normalizeAndDiff", {
-  enabled: false,
-  level: "debug",
-});
-
-/**
- * Returns true if `target` is the immediate parent of `base` in the same document.
- *
- * Example:
- * - base.path = ["internal", "__#1", "next"]
- * - target.path = ["internal", "__#1"]
- *
- * This is used to decide when to collapse a self/parent link that would create
- * a tight self-loop (e.g., obj.next -> obj) while allowing references to
- * higher ancestors (like an item's `items` pointing to its containing array).
- */
-function isImmediateParent(
-  target: NormalizedFullLink,
-  base: NormalizedFullLink,
-): boolean {
-  return (
-    target.id === base.id &&
-    target.space === base.space &&
-    target.path.length === base.path.length - 1 &&
-    target.path.every((seg, i) => seg === base.path[i])
-  );
-}
-
 export function normalizeAndDiff(
   runtime: IRuntime,
   tx: IExtendedStorageTransaction,
@@ -232,6 +209,54 @@ export function normalizeAndDiff(
     newValue = newValue.getAsLink();
   }
 
+  // Check for links that are data: URIs and inline them, by calling
+  // normalizeAndDiff on the contents of the link.
+  if (isLink(newValue)) {
+    const parsedLink = parseLink(newValue, link);
+    if (parsedLink.id.startsWith("data:")) {
+      diffLogger.debug(() =>
+        `[BRANCH_CELL_LINK] Data link detected, treating as contents at path=${pathStr}`
+      );
+      // Use the tx code to make sure we read it the same way
+      let dataValue: any = tx.readValueOrThrow({
+        ...parsedLink,
+        path: [],
+      }, options);
+      const path = [...parsedLink.path];
+      // If there is a link on the way to `path`, follow it, appending remaining
+      // path to the target link.
+      for (;;) {
+        if (isAnyCellLink(dataValue)) {
+          const dataLink = parseLink(dataValue, parsedLink);
+          dataValue = createSigilLinkFromParsedLink({
+            ...dataLink,
+            path: [...dataLink.path, ...path],
+          });
+          break;
+        }
+        if (path.length > 0) {
+          if (isRecord(dataValue)) {
+            dataValue = dataValue[path.shift()!];
+          } else {
+            dataValue = undefined;
+            break;
+          }
+        } else {
+          break;
+        }
+      }
+      return normalizeAndDiff(
+        runtime,
+        tx,
+        link,
+        dataValue,
+        context,
+        options,
+        seen,
+      );
+    }
+  }
+
   // If we're about to create a reference to ourselves, no-op
   if (areMaybeLinkAndNormalizedLinkSame(newValue, link)) {
     diffLogger.debug(() =>
@@ -318,48 +343,6 @@ export function normalizeAndDiff(
         seen,
       );
     }
-    if (parsedLink.id.startsWith("data:")) {
-      diffLogger.debug(() =>
-        `[BRANCH_CELL_LINK] Data link detected, treating as contents at path=${pathStr}`
-      );
-      // If there is a data link treat it as writing it's contents instead.
-
-      //  Use the tx code to make sure we read it the same way
-      let dataValue: any = tx.readValueOrThrow({
-        ...parsedLink,
-        path: [],
-      }, options);
-      const path = [...parsedLink.path];
-      for (;;) {
-        if (isAnyCellLink(dataValue)) {
-          const dataLink = parseLink(dataValue, parsedLink);
-          dataValue = createSigilLinkFromParsedLink({
-            ...dataLink,
-            path: [...dataLink.path, ...path],
-          });
-          break;
-        }
-        if (path.length > 0) {
-          if (isRecord(dataValue)) {
-            dataValue = dataValue[path.shift()!];
-          } else {
-            dataValue = undefined;
-            break;
-          }
-        } else {
-          break;
-        }
-      }
-      return normalizeAndDiff(
-        runtime,
-        tx,
-        link,
-        dataValue,
-        context,
-        options,
-        seen,
-      );
-    }
     if (
       isAnyCellLink(currentValue) &&
       areLinksSame(newValue, currentValue, link)
@@ -634,3 +617,26 @@ export function addCommonIDfromObjectID(
 
   traverse(obj);
 }
+
+/**
+ * Returns true if `target` is the immediate parent of `base` in the same document.
+ *
+ * Example:
+ * - base.path = ["internal", "__#1", "next"]
+ * - target.path = ["internal", "__#1"]
+ *
+ * This is used to decide when to collapse a self/parent link that would create
+ * a tight self-loop (e.g., obj.next -> obj) while allowing references to
+ * higher ancestors (like an item's `items` pointing to its containing array).
+ */
+function isImmediateParent(
+  target: NormalizedFullLink,
+  base: NormalizedFullLink,
+): boolean {
+  return (
+    target.id === base.id &&
+    target.space === base.space &&
+    target.path.length === base.path.length - 1 &&
+    target.path.every((seg, i) => seg === base.path[i])
+  );
+}