@valbuild/server 0.143.0 → 0.144.0

package/dist/valbuild-server.cjs.prod.js

@@ -20273,7 +20273,7 @@ function readFileOrUndefined$1(absolutePath) {
  * be uploaded first). On the way DOWN the same playlists are rewritten back to
  * relative names, which is what lets a published stream be plain static files.
  */
-function isRecord$2(value) {
+function isRecord$3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPlaylist$1(ref) {
@@ -20282,14 +20282,14 @@ function isPlaylist$1(ref) {
 
 /** The paths a video value holds, each with where in the value it sits. */
 function videoPathsOf(video) {
-  if (!isRecord$2(video) || typeof video.path !== "string") {
+  if (!isRecord$3(video) || typeof video.path !== "string") {
     return [];
   }
   const found = [{
     at: ["path"],
     path: video.path
   }];
-  if (isRecord$2(video.poster) && typeof video.poster.path === "string") {
+  if (isRecord$3(video.poster) && typeof video.poster.path === "string") {
     found.push({
       at: ["poster", "path"],
       path: video.poster.path
@@ -20297,7 +20297,7 @@ function videoPathsOf(video) {
   }
   if (Array.isArray(video.captions)) {
     video.captions.forEach((track, index) => {
-      if (isRecord$2(track) && typeof track.path === "string") {
+      if (isRecord$3(track) && typeof track.path === "string") {
         found.push({
           at: ["captions", String(index), "path"],
           path: track.path
@@ -20368,7 +20368,7 @@ function metadataOf(localRef, role, video) {
       height: video.height
     };
   }
-  if (role === "poster" && isRecord$2(video.poster)) {
+  if (role === "poster" && isRecord$3(video.poster)) {
     return {
       mimeType: video.poster.mimeType ?? mimeType,
       width: video.poster.width,
@@ -20384,7 +20384,7 @@ function metadataOf(localRef, role, video) {
  * Places a video's local files on Val Remote, each once, and remembers where.
  *
  * The one implementation of "upload a video" for every fix that does it: a
- * video field (`video:upload-remote`), and an entry of an `s.videoset()`
+ * video field (`video:upload-remote`), and an entry of an `s.videodir()`
  * (`videos:upload-remote`). What differs between the two is which files go up
  * and what their refs are hashed against, so those are the arguments.
  *
@@ -20477,7 +20477,7 @@ function resolveVideo(ctx) {
   }
   const resolved = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
   const video = resolved.source;
-  if (((_resolved$schema = resolved.schema) === null || _resolved$schema === void 0 ? void 0 : _resolved$schema.type) !== "video" || !isRecord$2(video) || typeof video.path !== "string") {
+  if (((_resolved$schema = resolved.schema) === null || _resolved$schema === void 0 ? void 0 : _resolved$schema.type) !== "video" || !isRecord$3(video) || typeof video.path !== "string") {
     return {
       success: false,
       result: {
@@ -20497,7 +20497,7 @@ function resolveVideo(ctx) {
  * The paths of a video FIELD that its fix moves.
  *
  * All of them for a video of its own. For a field picked from an
- * `s.videoset()` (`referencedModule`), only the poster and the captions: the
+ * `s.videodir()` (`referencedModule`), only the poster and the captions: the
  * video file is the set's — its key there — and moving it from here would
  * leave the field naming a file the set does not have. The set's own fix
  * (`videos:upload-remote`) moves it, and rewrites the fields that name it.
@@ -20670,6 +20670,192 @@ async function handleVideoDownloadRemote(ctx) {
   };
 }
 
+/**
+ * The fields that name an entry of a media collection by its key, and the
+ * patches that point them at a new key.
+ *
+ * A collection — `s.imagedir()`, `s.filedir()`, `s.videodir()` — is a record
+ * keyed by each entry's file path, and a field picked from it
+ * (`s.image(imagesVal)`, `s.file(filesVal)`, `s.video(videosVal)`) stores that
+ * key as its `path`. So when `--fix` renames a key — moving an entry of a
+ * `.remote()` collection to Val Remote renames it from the local path to the
+ * ref — every field holding the old key would name an entry the collection no
+ * longer has, and nothing could repair it afterwards.
+ *
+ * Two kinds of value name a key:
+ *
+ * - **A field whose schema is backed by the collection** (`referencedModule`).
+ * - **An inline image in rich text** whose `img` schema is backed by it
+ *   (`s.richtext({ img: s.image(imagesVal) })`). The field's own schema is
+ *   `richtext`, so a walk looking only for image leaves goes straight past
+ *   them — the Studio's reference scan learned that once already
+ *   (`getReferencedFiles`), and uses the same `forEachRichTextImage`.
+ *
+ * **A field is renamed when the key it names is the old key**, and "names" is
+ * `galleryKeyOf` in core: the field's `path` when that is a key, and otherwise
+ * the local path inside it when it is a ref. That is how a field is read
+ * (`fillFromGallery`) and how it is validated, so it is exactly the set of
+ * fields the rename would break. The second shape is real: an image uploaded
+ * THROUGH an `s.image(remoteGallery)` field in the Studio stores the ref in
+ * the field and keys the entry by the local path inside it, so uploading that
+ * entry here has to move the field to the entry's new key as well. A ref that
+ * is itself a key names its own entry, and is left alone.
+ *
+ * Nothing here imports `fixHandlers.ts` at runtime: that module calls this one.
+ */
+
+/** What of a `Service` the project-wide walk needs. */
+
+/** A value that names an entry of a collection by its key. */
+
+function isRecord$2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Whether a serialized schema is backed by `collection` anywhere in it. */
+function isBackedBy(schema, collection) {
+  if (Array.isArray(schema)) {
+    return schema.some(item => isBackedBy(item, collection));
+  }
+  if (!isRecord$2(schema)) {
+    return false;
+  }
+  if (schema.referencedModule === collection) {
+    return true;
+  }
+  return Object.values(schema).some(value => isBackedBy(value, collection));
+}
+
+/**
+ * The references already found, per service and collection.
+ *
+ * `val validate --fix` renames a key once per local entry, so a gallery of N
+ * local entries would otherwise walk the project N times — validating every
+ * module that uses the gallery each time. Caching per `Service` is exact, not
+ * an approximation: a `Service` answers `get` from the snapshot it was created
+ * with (`patch` writes to disk and changes nothing it returns), so the walk
+ * would find the same references every time. A new `Service` — the language
+ * server makes one after every edit — starts with nothing cached.
+ */
+const referencesByService = new WeakMap();
+
+/**
+ * Every value in the project that names an entry of `collection`, as the
+ * service's snapshot has it. Found once per service; see
+ * {@link referencesByService}.
+ */
+function collectionReferencesOf(service, collection) {
+  let byCollection = referencesByService.get(service);
+  if (!byCollection) {
+    byCollection = new Map();
+    referencesByService.set(service, byCollection);
+  }
+  let references = byCollection.get(collection);
+  if (!references) {
+    references = findCollectionReferences(service, collection);
+    // A walk that failed is not an answer; the next caller tries again.
+    references.catch(() => byCollection.delete(collection));
+    byCollection.set(collection, references);
+  }
+  return references;
+}
+
+/**
+ * The walk itself.
+ *
+ * Validated reads for the modules backed by the collection, because only
+ * those come back with their `.jsonValues()` entries loaded — an unvalidated
+ * read hands back each entry as a marker, and a field inside one would be
+ * invisible. Every other module is read once, unvalidated, to find out it is
+ * not one of them.
+ */
+async function findCollectionReferences(service, collection) {
+  const found = [];
+  for (const moduleFilePath of service.getModuleFilePaths()) {
+    const shallow = await service.get(moduleFilePath, "", {
+      validate: false
+    });
+    if (!isBackedBy(shallow.schema, collection)) {
+      continue;
+    }
+    const loaded = await service.get(moduleFilePath, "", {
+      validate: true
+    });
+    if (loaded.source === undefined || !loaded.schema) {
+      continue;
+    }
+    const add = (sourcePath, value) => {
+      if (isRecord$2(value) && typeof value.path === "string") {
+        found.push({
+          moduleFilePath,
+          sourcePath,
+          path: value.path
+        });
+      }
+    };
+    internal.traverseSchemaSource(loaded.source, loaded.schema, moduleFilePath, ({
+      source,
+      schema,
+      path: sourcePath
+    }) => {
+      if (schema.type === "image" || schema.type === "file" || schema.type === "video") {
+        if (schema.referencedModule === collection) {
+          add(sourcePath, source);
+        }
+      } else if (schema.type === "richtext") {
+        var _richTextImageSchema;
+        if (((_richTextImageSchema = internal.richTextImageSchema(schema)) === null || _richTextImageSchema === void 0 ? void 0 : _richTextImageSchema.referencedModule) === collection) {
+          internal.forEachRichTextImage(sourcePath, source, add);
+        }
+      }
+    });
+  }
+  return found;
+}
+
+/**
+ * The patch path of `sourcePath`. Not `sourceToPatchPath`: a collection's keys
+ * are file paths, and their dots do not survive its `split(".")`.
+ */
+function patchPathOf$1(sourcePath) {
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+  return core.Internal.splitModulePath(modulePath);
+}
+
+/**
+ * The patches that point every value naming a key in `renamed` at its new key.
+ *
+ * `renamed` is keyed by the collection's keys BEFORE the rename, and the
+ * collection is read as it is now — so call this before its own patch lands.
+ *
+ * One `add` on each value's `path`, so the alt text, hotspot, poster and
+ * captions beside it are never rewritten.
+ */
+async function collectionReferencePatches(service, collection, renamed) {
+  const collectionSource = (await service.get(collection, "", {
+    validate: false
+  })).source;
+  const keys = new Set(isRecord$2(collectionSource) ? Object.keys(collectionSource) : []);
+  const byModule = new Map();
+  for (const reference of await collectionReferencesOf(service, collection)) {
+    const key = core.Internal.media.galleryKeyOf(reference.path, candidate => keys.has(candidate));
+    if (key === null || !Object.prototype.hasOwnProperty.call(renamed, key)) {
+      continue;
+    }
+    const patch = byModule.get(reference.moduleFilePath) ?? [];
+    patch.push({
+      op: "add",
+      path: patchPathOf$1(reference.sourcePath).concat("path"),
+      value: renamed[key]
+    });
+    byModule.set(reference.moduleFilePath, patch);
+  }
+  return [...byModule].map(([moduleFilePath, patch]) => ({
+    moduleFilePath,
+    patch
+  }));
+}
+
 /**
  * What is out of step between a gallery's entries and its directory.
  *
@@ -20778,7 +20964,7 @@ function filesInDirectory({
 }
 
 /**
- * The fixes of an `s.videoset()` — the video twin of an image gallery.
+ * The fixes of an `s.videodir()` — the video twin of an image gallery.
  *
  * A set is a record keyed by each video's file path (an HLS stream by its
  * master playlist), so most of this is the gallery fixes again with the key as
@@ -21041,34 +21227,14 @@ async function filesNamedByVideoFields(service, options) {
 /**
  * The patches that point every `s.video(set)` field at a set entry's new key.
  *
- * One `add` on each field's `path`, so the description, poster, times and
- * captions beside it are never rewritten. A field of another set, or of no
- * set, is left alone even when its path is the same string: it names its own
- * file.
+ * The same walk an image or file collection's rename uses
+ * (`collectionReferencePatches`): one `add` on each field's `path`, so the
+ * description, poster, times and captions beside it are never rewritten, and
+ * a field of another set, or of no set, is left alone even when its path is
+ * the same string — it names its own file.
  */
 async function videosetReferencePatches(service, setModuleFilePath, renamed) {
-  const byModule = new Map();
-  for (const field of await videoFieldsOf(service)) {
-    if (field.schema.referencedModule !== setModuleFilePath) {
-      continue;
-    }
-    const value = field.source;
-    const current = isRecord$1(value) ? value.path : undefined;
-    if (typeof current !== "string" || !(current in renamed)) {
-      continue;
-    }
-    const patch = byModule.get(field.moduleFilePath) ?? [];
-    patch.push({
-      op: "add",
-      path: patchPathOf(field.sourcePath).concat("path"),
-      value: renamed[current]
-    });
-    byModule.set(field.moduleFilePath, patch);
-  }
-  return [...byModule].map(([moduleFilePath, patch]) => ({
-    moduleFilePath,
-    patch
-  }));
+  return collectionReferencePatches(service, setModuleFilePath, renamed);
 }
 
 /** The record at `sourcePath` and its entries, or why it could not be read. */
@@ -22652,13 +22818,13 @@ async function handleRemoteFileUpload(ctx) {
   return uploadRemoteFileCore(ctx, fileRefProp, fileSourceMetadata, resolveRemoteFileSchema);
 }
 
-// Gallery (s.imageset({ ... }).remote() / s.fileset({ ... }).remote()) upload.
+// Gallery (s.imagedir(dir, { ... }).remote() / s.filedir(dir, { ... }).remote()) upload.
 // Unlike a single image/file field, a gallery entry is keyed by its local file
 // path and the value is bare metadata (no FileSource), so we derive the file
 // ref from the key and synthesize the image/file schema from the record's
 // media options.
 async function handleRemoteGalleryFileUpload(ctx) {
-  var _ctx$validationError$;
+  var _ctx$validationError$, _ctx$remoteFiles$ctx$;
   if (!ctx.fix) {
     return {
       success: false,
@@ -22696,7 +22862,7 @@ async function handleRemoteGalleryFileUpload(ctx) {
   // `accept`/`dir` come from the RECORD that holds the entry, resolved
   // from the entry's PARENT path - not from the module root, which is only the
   // record when the gallery is the whole module. A nested gallery
-  // (s.object({ gallery: s.imageset(...) })) would otherwise synthesize a schema
+  // (s.object({ gallery: s.imagedir(...) })) would otherwise synthesize a schema
   // with no options and bake a validation hash into the remote ref that can
   // never validate, so a mismatch fails fast instead of uploading.
   const [, parentModulePath] = core.Internal.splitModuleFilePathAndModulePath(core.Internal.parentOfSourcePath(ctx.sourcePath));
@@ -22731,7 +22897,24 @@ async function handleRemoteGalleryFileUpload(ctx) {
       } : {})
     }
   };
-  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+  const uploaded = await uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+  const ref = (_ctx$remoteFiles$ctx$ = ctx.remoteFiles[ctx.sourcePath]) === null || _ctx$remoteFiles$ctx$ === void 0 ? void 0 : _ctx$remoteFiles$ctx$.ref;
+  if (!uploaded.success || !uploaded.shouldApplyPatch || ref === undefined) {
+    return uploaded;
+  }
+  // `createFixPatch` renames the entry's key to the ref. Every field picked
+  // from the gallery that holds the old key — and every rich text image from
+  // it — would then name an image the gallery no longer has, so they are
+  // pointed at the ref in the same run, as `videos:upload-remote` does.
+  const otherModulePatches = await collectionReferencePatches(ctx.service, ctx.moduleFilePath, {
+    [fileRef]: ref
+  });
+  return {
+    ...uploaded,
+    ...(otherModulePatches.length > 0 ? {
+      otherModulePatches
+    } : {})
+  };
 }
 async function handleRemoteFileDownload(ctx) {
   if (ctx.fix) {
@@ -22750,13 +22933,47 @@ async function handleRemoteFileDownload(ctx) {
     };
   }
 }
+
+/**
+ * `image:check-remote` / `file:check-remote`: core's "Remote image was not
+ * checked." — emitted for EVERY remote value of an `s.image().remote()` /
+ * `s.file().remote()`, wrong or not, because core cannot read the bytes or the
+ * ref's validation hash. It is a request to look, not a finding, so there is
+ * nothing to report here: `createFixPatch` does the looking (`checkRemoteRef`)
+ * and returns an error only for a ref that is actually wrong, with a fix where
+ * the ref only needs rewriting.
+ *
+ * So these stay a hand-off. Reporting core's message here instead would put an
+ * error on every remote image in a project, which is what the language server
+ * learned to stop doing (`mediaChecks.ts`).
+ */
 async function handleRemoteFileCheck() {
-  // Skip - no action needed
   return {
     success: true,
     shouldApplyPatch: true
   };
 }
+
+/**
+ * `images:check-remote` / `files:check-remote`: a gallery key that is wrong as
+ * a key — a remote URL in a gallery that is not `.remote()`, a ref that does
+ * not parse, one outside the gallery's directory (`validateMediaKey` in core).
+ *
+ * Unlike the singular codes, core emits these only when something IS wrong,
+ * and its message says what. There is nothing to look up and nothing to move,
+ * so it is reported as it is, for a person: only they know whether the key or
+ * the gallery's options are the mistake. It used to share the singular codes'
+ * handler, which hands off to `createFixPatch` — and that has no branch for a
+ * gallery key, so the error vanished and the module was reported valid.
+ *
+ * The same answer as `videos:check-remote`.
+ */
+async function handleGalleryCheckRemote(ctx) {
+  return {
+    success: false,
+    errorMessage: ctx.validationError.message
+  };
+}
 async function handleUniqueFolderCheck(ctx) {
   const value = ctx.validationError.value;
   if (!value || typeof value.dir !== "string") {
@@ -22951,9 +23168,9 @@ const currentFixHandlers = {
   "videos:check-unique-folder": handleUniqueFolderCheck,
   "videos:check-all-files": handleVideosetCheckAllFiles,
   "image:check-remote": handleRemoteFileCheck,
-  "images:check-remote": handleRemoteFileCheck,
+  "images:check-remote": handleGalleryCheckRemote,
   "file:check-remote": handleRemoteFileCheck,
-  "files:check-remote": handleRemoteFileCheck,
+  "files:check-remote": handleGalleryCheckRemote,
   "images:check-unique-folder": handleUniqueFolderCheck,
   "files:check-unique-folder": handleUniqueFolderCheck,
   "images:check-all-files": handleCheckAllFiles,