@valbuild/server 0.108.3 → 0.108.5

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

@@ -1040,7 +1040,7 @@ function errorMessage(e) {
   return String(e);
 }
 
-const jsonOps$1 = new patch.JSONOps();
+const jsonOps$2 = new patch.JSONOps();
 
 /**
  * Classification of a single patch op against a module's serialized schema,
@@ -1295,7 +1295,7 @@ function applyJsonValuesEntryPatches(args) {
           // on an entry that does not exist.
           continue;
         }
-        const applied = patch.applyPatch(patch.deepClone(content), jsonOps$1, [{
+        const applied = patch.applyPatch(patch.deepClone(content), jsonOps$2, [{
           op: "add",
           path: cls.subPath.concat(...(op.nestedFilePath ?? [])).concat("patch_id"),
           value: patchId
@@ -1349,7 +1349,7 @@ function applyJsonValuesEntryPatches(args) {
           patchId
         };
       }
-      const applied = patch.applyPatch(patch.deepClone(content), jsonOps$1, [rebased.value]);
+      const applied = patch.applyPatch(patch.deepClone(content), jsonOps$2, [rebased.value]);
       if (fp.result.isErr(applied)) {
         return {
           kind: "error",
@@ -1387,6 +1387,19 @@ function resolveExistingJsonPath(moduleFilePath, importPath) {
   return path__namespace.posix.join(moduleDir, importPath);
 }
 
+/**
+ * The outcome of {@link validateJsonValuesEntries}: the errors found inside the
+ * entries, plus the content of every entry that could be loaded, keyed by entry
+ * key.
+ *
+ * The content is part of the result because the errors are useless without it.
+ * They are reported at paths that point INSIDE an entry, and the module source
+ * on disk holds a `c.json(...)` marker there — so anything that has to resolve
+ * one of those paths (the `val validate --fix` handlers, chiefly) needs the very
+ * content this function has just loaded. Returning it costs nothing and is the
+ * only way to avoid loading every entry twice.
+ */
+
 /**
  * Validates the content of every `.jsonValues()` entry in a module by loading
  * each backing `*.val.json` (via its lazy import thunk) and checking it against
@@ -1439,14 +1452,19 @@ function resolveExistingJsonPath(moduleFilePath, importPath) {
  */
 async function validateJsonValuesEntries(schema, source, modulePath) {
   const out = {};
+  const loadedEntries = {};
+  const res = {
+    errors: out,
+    loadedEntries
+  };
   if (!(schema instanceof core.RecordSchema)) {
-    return out;
+    return res;
   }
   if (!schema["executeSerialize"]().jsonValues) {
-    return out;
+    return res;
   }
   if (source === null || typeof source !== "object" || Array.isArray(source)) {
-    return out;
+    return res;
   }
   for (const [key, marker] of Object.entries(source)) {
     const entryPath = core.Internal.createValPathOfItem(modulePath, key);
@@ -1482,6 +1500,10 @@ async function validateJsonValuesEntries(schema, source, modulePath) {
       }];
       continue;
     }
+    // Kept so a caller can substitute the content back into the module source:
+    // the entries have been paid for here, and a source that still holds
+    // markers cannot resolve a path INTO an entry (see the doc comment above).
+    loadedEntries[key] = content;
     const entryErrors = schema.validateJsonEntryContent(entryPath, content);
     if (entryErrors) {
       for (const [p, errs] of Object.entries(entryErrors)) {
@@ -1489,9 +1511,155 @@ async function validateJsonValuesEntries(schema, source, modulePath) {
       }
     }
   }
-  return out;
+  return res;
 }
 
+/**
+ * Given the `source` object-literal expression of a `.jsonValues()` record /
+ * router (the 3rd argument to `c.define`, via {@link analyzeValModule}),
+ * extracts each entry's `c.json(() => import("..."))` import path, keyed by
+ * entry key. Entries whose value is not a `c.json(...)` call are skipped.
+ */
+function analyzeJsonValuesEntries(source) {
+  const entries = new Map();
+  if (!ts__default["default"].isObjectLiteralExpression(source)) {
+    return entries;
+  }
+  for (const prop of source.properties) {
+    if (!ts__default["default"].isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key === null) {
+      continue;
+    }
+    const entry = analyzeCJsonCall(prop.initializer);
+    if (entry) {
+      entries.set(key, entry);
+    }
+  }
+  return entries;
+}
+function getPropertyKey(name) {
+  if (ts__default["default"].isStringLiteralLike(name)) {
+    return name.text;
+  }
+  if (ts__default["default"].isIdentifier(name)) {
+    return name.text;
+  }
+  return null;
+}
+function analyzeCJsonCall(node) {
+  // c.json(() => import("path"))
+  if (!ts__default["default"].isCallExpression(node) || !isCJson(node.expression)) {
+    return null;
+  }
+  const [thunk] = node.arguments;
+  if (!thunk) {
+    return null;
+  }
+  const importPath = getImportPathFromThunk(thunk);
+  if (importPath === null) {
+    return null;
+  }
+  return {
+    importPath
+  };
+}
+function isCJson(expr) {
+  // c.json
+  return ts__default["default"].isPropertyAccessExpression(expr) && ts__default["default"].isIdentifier(expr.expression) && expr.expression.text === "c" && ts__default["default"].isIdentifier(expr.name) && expr.name.text === "json";
+}
+function getImportPathFromThunk(thunk) {
+  // () => import("path")   (concise body)   OR   () => { return import("path"); }
+  if (!ts__default["default"].isArrowFunction(thunk)) {
+    return null;
+  }
+  let importCall;
+  if (ts__default["default"].isCallExpression(thunk.body)) {
+    importCall = thunk.body;
+  } else if (ts__default["default"].isBlock(thunk.body)) {
+    for (const stmt of thunk.body.statements) {
+      if (ts__default["default"].isReturnStatement(stmt) && stmt.expression && ts__default["default"].isCallExpression(stmt.expression)) {
+        importCall = stmt.expression;
+        break;
+      }
+    }
+  }
+  if (!importCall || !ts__default["default"].isCallExpression(importCall)) {
+    return null;
+  }
+  const isImport = importCall.expression.kind === ts__default["default"].SyntaxKind.ImportKeyword || ts__default["default"].isIdentifier(importCall.expression) && importCall.expression.text === "import";
+  if (!isImport) {
+    return null;
+  }
+  const arg = importCall.arguments[0];
+  if (arg && ts__default["default"].isStringLiteralLike(arg)) {
+    return arg.text;
+  }
+  return null;
+}
+
+/**
+ * Which `*.val.json` holds a `.jsonValues()` entry's content, given the module's
+ * `.val.ts`.
+ *
+ * Tooling that maps a validation `sourcePath` back to a place in a file needs
+ * this: for a jsonValues module the offending value is NOT in the `.val.ts` at
+ * all — that file only holds `c.json(() => import("./x.val.json"))` — so a
+ * resolver that only ever looks at the `.val.ts` can report the error but not
+ * where it lives, which for a record with hundreds of entries is not much of a
+ * report.
+ *
+ * Returns a path relative to the project root (leading slash), or undefined when
+ * the module has no such entry (not a jsonValues module, unparseable, or the key
+ * is not backed by a `c.json` thunk).
+ */
+function findJsonEntryFilePath(moduleFilePath, valTsSourceFile, entryKey) {
+  let analysis;
+  try {
+    analysis = analyzeValModule(valTsSourceFile);
+  } catch {
+    return undefined;
+  }
+  if (fp.result.isErr(analysis)) {
+    return undefined;
+  }
+  const entry = analyzeJsonValuesEntries(analysis.value.source).get(entryKey);
+  if (!entry) {
+    return undefined;
+  }
+  return resolveExistingJsonPath(moduleFilePath, entry.importPath);
+}
+
+const jsonOps$1 = new patch.JSONOps();
+
+/**
+ * Substitutes loaded `.jsonValues()` entry content back into a module's root
+ * record, in place of the `c.json(...)` markers the `.val.ts` holds.
+ *
+ * Only entries that actually loaded are replaced: an entry whose file is missing
+ * or unparseable keeps its marker, so the failure stays visible as the
+ * validation error it already produced rather than becoming a silent `undefined`
+ * further down.
+ */
+function withLoadedJsonEntries(source, loadedEntries) {
+  if (Object.keys(loadedEntries).length === 0) {
+    return source;
+  }
+  if (!isSourceObject(source)) {
+    return source;
+  }
+  return {
+    ...source,
+    ...loadedEntries
+  };
+}
+
+/** A non-null, non-array source object: the shape a record/router source has. */
+function isSourceObject(source) {
+  return typeof source === "object" && source !== null && !Array.isArray(source);
+}
 async function createService(projectRoot, host = {
   ...ts__default["default"].sys,
   writeFile: (fileName, data, encoding) => {
@@ -1530,13 +1698,16 @@ class Service {
   getModuleFilePaths() {
     return Object.keys(this.extracted.sources);
   }
+  serializedSchemaOf(moduleFilePath) {
+    return this.extracted.serializedSchemas[moduleFilePath];
+  }
   async get(moduleFilePath, modulePath, options) {
     const opts = options ?? {
       validate: true
     };
     const source = this.extracted.sources[moduleFilePath];
     const schema = this.extracted.schemas[moduleFilePath];
-    const serializedSchema = this.extracted.serializedSchemas[moduleFilePath];
+    const serializedSchema = this.serializedSchemaOf(moduleFilePath);
     const moduleError = this.extracted.moduleErrors.find(e => e.path === moduleFilePath);
     // A module whose `def()` threw is recorded WITHOUT a path: the import never
     // got far enough to reveal one, so it cannot be matched above. Those errors
@@ -1568,6 +1739,12 @@ class Service {
     // entry content, or an unsupported nested `.jsonValues()`, as VALID, and CI
     // gates on that.
     let jsonValuesModuleError;
+    // The source as it is on disk holds a `c.json(...)` marker for every
+    // `.jsonValues()` entry, and validation reports errors at paths INSIDE those
+    // entries. Resolving such a path against the marker source is impossible —
+    // it throws — so the loaded content is substituted back in before anything
+    // downstream (the `val validate --fix` handlers, chiefly) tries.
+    let resolvedFromSource = source;
     if (opts.validate) {
       const nested = findNestedJsonValuesRecords(serializedSchema);
       if (nested.length > 0) {
@@ -1580,7 +1757,11 @@ class Service {
         // accepted cost of having no revalidation token (locked decision #3):
         // validation is allowed to be slower at scale, but it is not allowed to
         // silently skip content.
-        const entryErrors = await validateJsonValuesEntries(schema, source, moduleFilePath);
+        const {
+          errors: entryErrors,
+          loadedEntries
+        } = await validateJsonValuesEntries(schema, source, moduleFilePath);
+        resolvedFromSource = withLoadedJsonEntries(source, loadedEntries);
         if (Object.keys(entryErrors).length > 0) {
           // Concatenate per path, never overwrite: an entry written inline is
           // reported BOTH by the record-level validation (which checks the
@@ -1598,7 +1779,7 @@ class Service {
         }
       }
     }
-    const resolved = core.Internal.resolvePath(modulePath, source, serializedSchema);
+    const resolved = core.Internal.resolvePath(modulePath, resolvedFromSource, serializedSchema);
     const sourcePath = resolved.path ? [moduleFilePath, resolved.path].join(".") : moduleFilePath;
     if (!validation && !moduleError && !jsonValuesModuleError) {
       return {
@@ -1629,8 +1810,126 @@ class Service {
       }
     };
   }
+
+  /**
+   * Applies a patch to a module's files.
+   *
+   * A `.jsonValues()` entry's content is not in the `.val.ts` — that file holds
+   * only `c.json(() => import("./x.val.json"))` — so an op whose path descends
+   * into an entry has to be replayed against the backing `*.val.json` instead.
+   * That routing is the same one the Studio's commit flow does in
+   * `ValOps.prepare`; both classify with {@link classifyJsonValuesOp} and rebase
+   * with {@link rebaseContentOp}, so a CLI fix and a Studio publish write the
+   * same file the same way.
+   */
   async patch(moduleFilePath, patch) {
-    await patchValFile(moduleFilePath, this.projectRoot, patch, this.sourceFileHandler);
+    const serializedSchema = this.serializedSchemaOf(moduleFilePath);
+    const valTsOps = [];
+    const entryOps = new Map();
+    const classify = opPath => serializedSchema ? classifyJsonValuesOp(serializedSchema, opPath) : {
+      kind: "normal"
+    };
+    for (const op of patch) {
+      const cls = classify(op.path);
+      // `move` and `copy` read a SECOND path, and `rebaseContentOp` slices
+      // `from` by the same prefix it slices `path` by. So an op whose two ends
+      // are not in the same place is not merely unsupported, it is silently
+      // wrong: a copy INTO an entry from anywhere else gets its `from`
+      // reinterpreted as a path inside the destination's `*.val.json` and reads
+      // the wrong value. `ValOps.prepare` guards this on the publish path; both
+      // ends have to be classified here for the same reason.
+      const fromCls = op.op === "move" || op.op === "copy" ? classify(op.from) : undefined;
+      if (cls.kind === "normal") {
+        // Unreachable while `.jsonValues()` is root-only -- every top-level path
+        // in such a module IS an entry key, so a normal destination means the
+        // module has no jsonValues record and the source cannot be in one
+        // either. Kept because it is the half of the guard that stops being
+        // theoretical the moment root-only is relaxed.
+        if (fromCls && fromCls.kind !== "normal") {
+          throw Error(`Cannot ${op.op} out of the .jsonValues() entry '${fromCls.entryKey}' of ${moduleFilePath}: the entry's content is not in the .val.ts`);
+        }
+        valTsOps.push(op);
+        continue;
+      }
+      if (cls.recordPath.length > 0) {
+        // Nested `.jsonValues()` is rejected as a module error before any fix
+        // runs, so reaching here means the contract moved without this moving
+        // with it. Refuse rather than write to the wrong file.
+        throw Error(`Cannot patch a nested .jsonValues() record in ${moduleFilePath}: only a root record/router is supported`);
+      }
+      if (cls.subPath.length === 0) {
+        // Adding, removing or replacing a whole entry means writing the
+        // `*.val.json` AND rewriting the `c.json(...)` reference in the
+        // `.val.ts`. Nothing that reaches `Service.patch` produces those today
+        // (`val validate --fix` only ever corrects values inside an entry), and
+        // silently applying it to the `.val.ts` alone would leave the module
+        // pointing at a file that does not exist.
+        throw Error(`Cannot ${op.op} the whole .jsonValues() entry '${cls.entryKey}' of ${moduleFilePath} through Service.patch: only edits INSIDE an entry are supported`);
+      }
+      if (fromCls && (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey)) {
+        throw Error(`Cannot ${op.op} into the .jsonValues() entry '${cls.entryKey}' of ${moduleFilePath} from outside it: each entry is a separate file`);
+      }
+      const ops = entryOps.get(cls.entryKey);
+      if (ops) {
+        ops.push(op);
+      } else {
+        entryOps.set(cls.entryKey, [op]);
+      }
+    }
+    // When nothing is routed away, hand the patch over untouched: an empty
+    // `valTsOps` would otherwise rewrite the `.val.ts` for no reason.
+    if (entryOps.size === 0) {
+      await patchValFile(moduleFilePath, this.projectRoot, patch, this.sourceFileHandler);
+      return;
+    }
+    if (valTsOps.length > 0) {
+      await patchValFile(moduleFilePath, this.projectRoot, valTsOps, this.sourceFileHandler);
+    }
+    for (const [entryKey, ops] of entryOps) {
+      this.patchJsonValuesEntry(moduleFilePath, entryKey, ops);
+    }
+  }
+
+  /** Replays content ops against one `.jsonValues()` entry's `*.val.json`. */
+  patchJsonValuesEntry(moduleFilePath, entryKey, ops) {
+    const valTsPath = this.sourceFileHandler.resolveSourceModulePath(getSyntheticContainingPath(this.projectRoot), `.${moduleFilePath.replace(".val.ts", ".val").replace(".val.js", ".val").replace(".val.jsx", ".val").replace(".val.tsx", ".val")}`);
+    const sourceFile = this.sourceFileHandler.getSourceFile(valTsPath);
+    if (!sourceFile) {
+      throw Error(`Source file ${valTsPath} not found`);
+    }
+    // The import specifier is authoritative, not the derived path: entries may
+    // be hand-placed (hybrid authoring), so deriving would write a file the
+    // module does not read.
+    const jsonPath = findJsonEntryFilePath(moduleFilePath, sourceFile, entryKey);
+    if (!jsonPath) {
+      throw Error(`Could not find the '*.val.json' backing .jsonValues() entry '${entryKey}' of ${moduleFilePath}`);
+    }
+    const absoluteJsonPath = path__namespace["default"].join(this.projectRoot, jsonPath);
+    const text = this.sourceFileHandler.host.readFile(absoluteJsonPath);
+    if (text === undefined) {
+      throw Error(`Could not read jsonValues entry file: ${jsonPath}`);
+    }
+    let content;
+    try {
+      content = JSON.parse(text);
+    } catch (err) {
+      throw new Error(`Could not parse jsonValues entry file ${jsonPath}`, {
+        cause: err
+      });
+    }
+    for (const op of ops) {
+      // Root record / router only, so the prefix is exactly the entry key.
+      const rebased = rebaseContentOp(op, 1);
+      if (fp.result.isErr(rebased)) {
+        throw Error(`Could not apply ${op.op} to jsonValues entry '${entryKey}' of ${moduleFilePath}: ${rebased.error.message}`);
+      }
+      const applied = patch.applyPatch(patch.deepClone(content), jsonOps$1, [rebased.value]);
+      if (fp.result.isErr(applied)) {
+        throw Error(`Could not apply ${op.op} to ${jsonPath}: ${applied.error.message}`);
+      }
+      content = applied.value;
+    }
+    this.sourceFileHandler.writeFile(absoluteJsonPath, JSON.stringify(content, null, 2) + "\n", "utf8");
   }
   dispose() {
     // No-op: the vm-based loader holds no disposable resources.
@@ -1695,92 +1994,6 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto__default["default"].createHmac("sha256", sessionKey).update(`${jwtHeaderBase64}.${payloadBase64}`).digest("base64")}`;
 }
 
-/**
- * Given the `source` object-literal expression of a `.jsonValues()` record /
- * router (the 3rd argument to `c.define`, via {@link analyzeValModule}),
- * extracts each entry's `c.json(() => import("..."))` import path, keyed by
- * entry key. Entries whose value is not a `c.json(...)` call are skipped.
- */
-function analyzeJsonValuesEntries(source) {
-  const entries = new Map();
-  if (!ts__default["default"].isObjectLiteralExpression(source)) {
-    return entries;
-  }
-  for (const prop of source.properties) {
-    if (!ts__default["default"].isPropertyAssignment(prop)) {
-      continue;
-    }
-    const key = getPropertyKey(prop.name);
-    if (key === null) {
-      continue;
-    }
-    const entry = analyzeCJsonCall(prop.initializer);
-    if (entry) {
-      entries.set(key, entry);
-    }
-  }
-  return entries;
-}
-function getPropertyKey(name) {
-  if (ts__default["default"].isStringLiteralLike(name)) {
-    return name.text;
-  }
-  if (ts__default["default"].isIdentifier(name)) {
-    return name.text;
-  }
-  return null;
-}
-function analyzeCJsonCall(node) {
-  // c.json(() => import("path"))
-  if (!ts__default["default"].isCallExpression(node) || !isCJson(node.expression)) {
-    return null;
-  }
-  const [thunk] = node.arguments;
-  if (!thunk) {
-    return null;
-  }
-  const importPath = getImportPathFromThunk(thunk);
-  if (importPath === null) {
-    return null;
-  }
-  return {
-    importPath
-  };
-}
-function isCJson(expr) {
-  // c.json
-  return ts__default["default"].isPropertyAccessExpression(expr) && ts__default["default"].isIdentifier(expr.expression) && expr.expression.text === "c" && ts__default["default"].isIdentifier(expr.name) && expr.name.text === "json";
-}
-function getImportPathFromThunk(thunk) {
-  // () => import("path")   (concise body)   OR   () => { return import("path"); }
-  if (!ts__default["default"].isArrowFunction(thunk)) {
-    return null;
-  }
-  let importCall;
-  if (ts__default["default"].isCallExpression(thunk.body)) {
-    importCall = thunk.body;
-  } else if (ts__default["default"].isBlock(thunk.body)) {
-    for (const stmt of thunk.body.statements) {
-      if (ts__default["default"].isReturnStatement(stmt) && stmt.expression && ts__default["default"].isCallExpression(stmt.expression)) {
-        importCall = stmt.expression;
-        break;
-      }
-    }
-  }
-  if (!importCall || !ts__default["default"].isCallExpression(importCall)) {
-    return null;
-  }
-  const isImport = importCall.expression.kind === ts__default["default"].SyntaxKind.ImportKeyword || ts__default["default"].isIdentifier(importCall.expression) && importCall.expression.text === "import";
-  if (!isImport) {
-    return null;
-  }
-  const arg = importCall.arguments[0];
-  if (arg && ts__default["default"].isStringLiteralLike(arg)) {
-    return arg.text;
-  }
-  return null;
-}
-
 /* eslint-disable @typescript-eslint/no-unused-vars */
 const jsonOps = new patch.JSONOps();
 const tsOps = new TSOps(document => {
@@ -2655,7 +2868,9 @@ class ValOps {
       const res = schema["executeValidate"](path, source);
       // For `.jsonValues()` records, executeValidate only checks the entry
       // markers; load + validate each entry's backing `*.val.json` content here.
-      const jsonValuesErrors = await validateJsonValuesEntries(schema, source, path);
+      const {
+        errors: jsonValuesErrors
+      } = await validateJsonValuesEntries(schema, source, path);
       for (const [sourcePathS, entryErrors] of Object.entries(jsonValuesErrors)) {
         const sourcePath = sourcePathS;
         if (!errors[path]) {
@@ -12520,38 +12735,6 @@ function traverseObjectLiteral(node, sourceFile) {
   }, {});
 }
 
-/**
- * Which `*.val.json` holds a `.jsonValues()` entry's content, given the module's
- * `.val.ts`.
- *
- * Tooling that maps a validation `sourcePath` back to a place in a file needs
- * this: for a jsonValues module the offending value is NOT in the `.val.ts` at
- * all — that file only holds `c.json(() => import("./x.val.json"))` — so a
- * resolver that only ever looks at the `.val.ts` can report the error but not
- * where it lives, which for a record with hundreds of entries is not much of a
- * report.
- *
- * Returns a path relative to the project root (leading slash), or undefined when
- * the module has no such entry (not a jsonValues module, unparseable, or the key
- * is not backed by a `c.json` thunk).
- */
-function findJsonEntryFilePath(moduleFilePath, valTsSourceFile, entryKey) {
-  let analysis;
-  try {
-    analysis = analyzeValModule(valTsSourceFile);
-  } catch {
-    return undefined;
-  }
-  if (fp.result.isErr(analysis)) {
-    return undefined;
-  }
-  const entry = analyzeJsonValuesEntries(analysis.value.source).get(entryKey);
-  if (!entry) {
-    return undefined;
-  }
-  return resolveExistingJsonPath(moduleFilePath, entry.importPath);
-}
-
 /**
  * Replays a `val debug` snapshot: applies its patches the way /save does and
  * validates the result.
@@ -12668,6 +12851,7 @@ exports.ValSourceFileHandler = ValSourceFileHandler;
 exports.analyzeValModule = analyzeValModule;
 exports.awaitValLoginConfirmation = awaitValLoginConfirmation;
 exports.checkRemoteRef = checkRemoteRef;
+exports.classifyJsonValuesOp = classifyJsonValuesOp;
 exports.compareWithCapturedReport = compareWithCapturedReport;
 exports.createDefaultValFSHost = createDefaultValFSHost;
 exports.createFixPatch = createFixPatch;
@@ -12714,6 +12898,7 @@ exports.patchSourceFile = patchSourceFile;
 exports.persistPersonalAccessToken = persistPersonalAccessToken;
 exports.readCapturedReport = readCapturedReport;
 exports.readPatchStore = readPatchStore;
+exports.rebaseContentOp = rebaseContentOp;
 exports.replaySnapshot = replaySnapshot;
 exports.safeReadGit = safeReadGit;
 exports.startValLogin = startValLogin;