@valbuild/server 0.146.2 → 0.147.0

package/dist/getJsonEntryAtCommit-e96beb9e.cjs.dev.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var ts = require('typescript');
+var ValRouterCore = require('./ValRouterCore-3fd3d444.cjs.dev.js');
+var fp = require('@valbuild/core/fp');
+var jsonValuesModule = require('./jsonValuesModule-8ae503a8.cjs.dev.js');
+require('buffer');
+require('@valbuild/core');
+require('@valbuild/shared/internal');
+require('zod');
+require('zod-validation-error');
+require('@valbuild/core/patch');
+require('image-size');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+/**
+ * One `.jsonValues()` entry's content, as it was at a commit.
+ *
+ * The history pane renders a commit through the real field components, and a
+ * `.jsonValues()` record's source is only `{_type:"json"}` markers - the
+ * content lives in a separate `*.val.json` per entry, fetched on demand. The
+ * live Studio fetches it from `GET /json`; the commit pane had nothing to
+ * fetch from, so every entry stayed a marker and rendered as though the field
+ * were empty. Which is worse than an error: an empty value is a claim, and it
+ * was a false one.
+ *
+ * ## Why this needs the module's own `.val.ts`
+ *
+ * There is no derivable relationship between a record key and its entry file.
+ * From the example app:
+ *
+ *   "/support/getting-started": c.json(() => import("./content/getting-started.val.json"))
+ *   "/support/faq":             c.json(() => import("./content/faq.val.json"))
+ *
+ * The key is a route and the path is whatever the author wrote. The only place
+ * the two are related is the `import()` literal inside the `.val.ts`, which is
+ * why `findJsonEntryFilePathsInSource` reads them out of the AST too. The
+ * commit archive stores the module's SOURCE (the markers) and its schema, not
+ * its text - so the text is fetched from git at that commit and parsed here.
+ *
+ * Two round trips per entry, then: the module, and the entry. The module's
+ * parse is worth caching per (commit, module) by the caller; nothing here does,
+ * because a `ValOps` is not a cache and the endpoint above it is the layer that
+ * knows how long a commit stays interesting.
+ */
+async function getJsonEntryAtCommit(ops, commitSha, moduleFilePath, key) {
+  const moduleGitPath = ops.gitPathOfModule(moduleFilePath);
+  if (fp.result.isErr(moduleGitPath)) {
+    return moduleGitPath;
+  }
+  const moduleRes = await ops.getFileAtCommit(commitSha, moduleGitPath.value, false);
+  if (fp.result.isErr(moduleRes)) {
+    return moduleRes;
+  }
+  const entryPath = findEntryImportPath(moduleFilePath, moduleGitPath.value, moduleRes.value.toString("utf-8"), key);
+  if (fp.result.isErr(entryPath)) {
+    return entryPath;
+  }
+  // The entry path resolved above is PROJECT-relative, like the module path it
+  // came from; the git path needs the root in front of it, and the ops are what
+  // know the root. Reusing gitPathOfModule rather than re-deriving the prefix:
+  // a `.val.json` is not a module, but "project-relative path -> repo path" is
+  // the same question and one implementation of it is the point.
+  const entryGitPath = ops.gitPathOfModule(entryPath.value);
+  if (fp.result.isErr(entryGitPath)) {
+    return entryGitPath;
+  }
+  const entryRes = await ops.getFileAtCommit(commitSha, entryGitPath.value, false);
+  if (fp.result.isErr(entryRes)) {
+    return entryRes;
+  }
+  try {
+    return fp.result.ok(JSON.parse(entryRes.value.toString("utf-8")));
+  } catch (err) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: entryGitPath.value,
+      message: `not valid JSON at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
+
+/**
+ * The `import()` path a key's entry is behind, from the module's text.
+ *
+ * Exported for its own test: this is the part with a real chance of being
+ * wrong, and it is pure.
+ */
+function findEntryImportPath(moduleFilePath,
+/**
+ * The same module, repository-relative, for error reporting only.
+ *
+ * A `gitPath` in a HistoryError is a REPOSITORY path - that is what every
+ * other history helper reports, and what a reader can paste into a `git show`
+ * - so reporting the project-relative ModuleFilePath here named a file that
+ * does not exist at that path for any project not rooted at the repo root.
+ */
+moduleGitPath, valTsSource, key) {
+  const sourceFile = ts__default["default"].createSourceFile(moduleFilePath, valTsSource, ts__default["default"].ScriptTarget.ES2015, true);
+  let analysis;
+  try {
+    analysis = jsonValuesModule.analyzeValModule(sourceFile);
+  } catch (err) {
+    // `file-unavailable` rather than a kind of its own: the module's TEXT is
+    // the file we could not use, and adding a wire kind for "unparseable"
+    // would be a new case every reader has to handle to say the same thing.
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `could not parse the module at this commit: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  if (fp.result.isErr(analysis)) {
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: "could not read the module at this commit"
+    });
+  }
+  const entries = jsonValuesModule.analyzeJsonValuesEntries(analysis.value.source);
+  const entry = entries.get(key);
+  if (entry === undefined) {
+    /*
+     * Reported, not treated as empty. A key with no entry at this commit means
+     * the entry was added later - so "there is nothing to show for it here" is
+     * the true answer, and rendering an empty field instead would say the
+     * author had left it blank.
+     */
+    return fp.result.err({
+      kind: "file-unavailable",
+      gitPath: moduleGitPath,
+      message: `'${key}' had no entry at this commit`
+    });
+  }
+  const moduleDir = ValRouterCore.posixPath.dirname(moduleFilePath);
+  return fp.result.ok(ValRouterCore.posixPath.join(moduleDir, entry.importPath));
+}
+
+exports.findEntryImportPath = findEntryImportPath;
+exports.getJsonEntryAtCommit = getJsonEntryAtCommit;

package/dist/jsonValuesModule-427d68c8.esm.js

@@ -0,0 +1,273 @@
+import ts from 'typescript';
+import { pipe, result } from '@valbuild/core/fp';
+
+class ValSyntaxError {
+  constructor(message, node) {
+    this.message = message;
+    this.node = node;
+  }
+}
+function forEachError(tree, callback) {
+  if (Array.isArray(tree)) {
+    for (const subtree of tree) {
+      forEachError(subtree, callback);
+    }
+  } else {
+    callback(tree);
+  }
+}
+function flatMapErrors(tree, cb) {
+  const result = [];
+  forEachError(tree, error => result.push(cb(error)));
+  return result;
+}
+function formatSyntaxError(error, sourceFile) {
+  const pos = sourceFile.getLineAndCharacterOfPosition(error.node.pos);
+  return `${pos.line}:${pos.character} ${error.message}`;
+}
+function formatSyntaxErrorTree(tree, sourceFile) {
+  return flatMapErrors(tree, error => formatSyntaxError(error, sourceFile));
+}
+function isLiteralPropertyName(name) {
+  return ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name);
+}
+function validateObjectProperties(nodes) {
+  const errors = [];
+  for (const node of nodes) {
+    if (!ts.isPropertyAssignment(node)) {
+      errors.push(new ValSyntaxError("Object literal element must be property assignment", node));
+    } else if (!isLiteralPropertyName(node.name)) {
+      errors.push(new ValSyntaxError("Object literal element key must be an identifier or a literal", node));
+    }
+  }
+  if (errors.length > 0) {
+    return result.err(errors);
+  }
+  return result.ok(nodes);
+}
+
+/**
+ * Validates that the expression is a JSON compatible type of expression without
+ * validating its children.
+ */
+function shallowValidateExpression(value) {
+  return ts.isStringLiteralLike(value) || ts.isNumericLiteral(value) || value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword || value.kind === ts.SyntaxKind.NullKeyword || ts.isArrayLiteralExpression(value) || ts.isObjectLiteralExpression(value) ? undefined : new ValSyntaxError("Expression must be a literal", value);
+}
+
+/**
+ * Evaluates the expression as a JSON value
+ */
+function evaluateExpression(value) {
+  // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
+  // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
+  // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
+  // https://github.com/microsoft/TypeScript/blob/4b794fe1dd0d184d3f8f17e94d8187eace57c91e/src/compiler/types.ts#L2127-L2131
+
+  if (ts.isStringLiteralLike(value)) {
+    return result.ok(value.text);
+  } else if (ts.isNumericLiteral(value)) {
+    return result.ok(Number(value.text));
+  } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
+    return result.ok(true);
+  } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
+    return result.ok(false);
+  } else if (value.kind === ts.SyntaxKind.NullKeyword) {
+    return result.ok(null);
+  } else if (ts.isArrayLiteralExpression(value)) {
+    return result.all(value.elements.map(evaluateExpression));
+  } else if (ts.isObjectLiteralExpression(value)) {
+    return pipe(validateObjectProperties(value.properties), result.flatMap(assignments => pipe(assignments.map(assignment => pipe(evaluateExpression(assignment.initializer), result.map(value => [assignment.name.text, value]))), result.all)), result.map(Object.fromEntries));
+  } else {
+    return result.err(new ValSyntaxError("Expression must be a literal", value));
+  }
+}
+function findObjectPropertyAssignment(value, key) {
+  return pipe(validateObjectProperties(value.properties), result.flatMap(assignments => {
+    const matchingAssignments = assignments.filter(assignment => assignment.name.text === key);
+    if (matchingAssignments.length === 0) return result.ok(undefined);
+    if (matchingAssignments.length > 1) {
+      return result.err(new ValSyntaxError(`Object key "${key}" is ambiguous`, value));
+    }
+    const [assignment] = matchingAssignments;
+    return result.ok(assignment);
+  }));
+}
+function validateInitializers(nodes) {
+  for (const node of nodes) {
+    if (ts.isSpreadElement(node)) {
+      return new ValSyntaxError("Unexpected spread element", node);
+    }
+  }
+  return undefined;
+}
+
+function isPath(node, path) {
+  let currentNode = node;
+  for (let i = path.length - 1; i > 0; --i) {
+    const name = path[i];
+    if (!ts.isPropertyAccessExpression(currentNode)) {
+      return false;
+    }
+    if (!ts.isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+      return false;
+    }
+    currentNode = currentNode.expression;
+  }
+  return ts.isIdentifier(currentNode) && currentNode.text === path[0];
+}
+function validateArguments(node, validators) {
+  return result.allV([node.arguments.length === validators.length ? result.voidOk : result.err(new ValSyntaxError(`Expected ${validators.length} arguments`, node)), ...node.arguments.slice(0, validators.length).map((argument, index) => validators[index](argument))]);
+}
+function analyzeDefaultExport(node) {
+  const cDefine = node.expression;
+  if (!ts.isCallExpression(cDefine)) {
+    return result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
+  }
+  if (!isPath(cDefine.expression, ["c", "define"])) {
+    return result.err(new ValSyntaxError("Expected default expression to be calling c.define", cDefine.expression));
+  }
+  return pipe(validateArguments(cDefine, [id => {
+    // TODO: validate ID value here?
+    if (!ts.isStringLiteralLike(id)) {
+      return result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
+    }
+    return result.voidOk;
+  }, () => {
+    return result.voidOk;
+  }, () => {
+    return result.voidOk;
+  }]), result.map(() => {
+    const [, schema, source] = cDefine.arguments;
+    return {
+      schema,
+      source
+    };
+  }));
+}
+function analyzeValModule(sourceFile) {
+  const analysis = sourceFile.forEachChild(node => {
+    if (ts.isExportAssignment(node)) {
+      return analyzeDefaultExport(node);
+    }
+  });
+  if (!analysis) {
+    throw Error("Failed to find fixed content node in val module");
+  }
+  return analysis;
+}
+
+/**
+ * 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.isObjectLiteralExpression(source)) {
+    return entries;
+  }
+  for (const prop of source.properties) {
+    if (!ts.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;
+}
+
+/**
+ * Every key of a `.jsonValues()` record's source literal, thunked or not.
+ *
+ * {@link analyzeJsonValuesEntries} answers "which entries have a file behind
+ * them", which is the question for resolving a path. This is the other one:
+ * which keys the record HAS. They differ on a value that is not a
+ * `c.json(...)` call - written inline, or mid-edit - and telling an existing
+ * key from a new one is what decides whether a whole-record write adds a
+ * `c.json(...)` thunk or replaces one. Using the thunk set for that would
+ * insert a second property with a key the literal already has.
+ */
+function jsonValuesRecordKeys(source) {
+  const keys = [];
+  if (!ts.isObjectLiteralExpression(source)) {
+    return keys;
+  }
+  for (const prop of source.properties) {
+    if (!ts.isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key !== null) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+function getPropertyKey(name) {
+  if (ts.isStringLiteralLike(name)) {
+    return name.text;
+  }
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+  return null;
+}
+function analyzeCJsonCall(node) {
+  // c.json(() => import("path"))
+  if (!ts.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.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "c" && ts.isIdentifier(expr.name) && expr.name.text === "json";
+}
+function getImportPathFromThunk(thunk) {
+  // () => import("path")   (concise body)   OR   () => { return import("path"); }
+  if (!ts.isArrowFunction(thunk)) {
+    return null;
+  }
+  let importCall;
+  if (ts.isCallExpression(thunk.body)) {
+    importCall = thunk.body;
+  } else if (ts.isBlock(thunk.body)) {
+    for (const stmt of thunk.body.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+        importCall = stmt.expression;
+        break;
+      }
+    }
+  }
+  if (!importCall || !ts.isCallExpression(importCall)) {
+    return null;
+  }
+  const isImport = importCall.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(importCall.expression) && importCall.expression.text === "import";
+  if (!isImport) {
+    return null;
+  }
+  const arg = importCall.arguments[0];
+  if (arg && ts.isStringLiteralLike(arg)) {
+    return arg.text;
+  }
+  return null;
+}
+
+export { analyzeValModule as a, formatSyntaxError as b, analyzeJsonValuesEntries as c, formatSyntaxErrorTree as d, findObjectPropertyAssignment as e, flatMapErrors as f, evaluateExpression as g, jsonValuesRecordKeys as j, shallowValidateExpression as s, validateInitializers as v };