@valbuild/server 0.146.2 → 0.147.0

package/dist/ops-0d05feaf.esm.js

@@ -0,0 +1,353 @@
+import ts from 'typescript';
+import { pipe, result } from '@valbuild/core/fp';
+import { a as analyzeValModule, e as findObjectPropertyAssignment, s as shallowValidateExpression, g as evaluateExpression, v as validateInitializers } from './jsonValuesModule-427d68c8.esm.js';
+import { PatchError, deepEqual, parseAndValidateArrayIndex, isNotRoot } from '@valbuild/core/patch';
+
+function isValidIdentifier(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  if (!ts.isIdentifierStart(text.charCodeAt(0), ts.ScriptTarget.ES2020)) {
+    return false;
+  }
+  for (let i = 1; i < text.length; ++i) {
+    if (!ts.isIdentifierPart(text.charCodeAt(i), ts.ScriptTarget.ES2020)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createPropertyAssignment(key, value) {
+  return ts.factory.createPropertyAssignment(isValidIdentifier(key) ? ts.factory.createIdentifier(key) : ts.factory.createStringLiteral(key), toExpression(value));
+}
+
+/**
+ * Builds the expression `c.json(() => import("<importPath>"))` used to reference
+ * a lazily-loaded `*.val.json` entry of a `.jsonValues()` record.
+ */
+function createValJsonReference(importPath) {
+  // () => import("<importPath>")
+  // NOTE: an `import` identifier prints as the dynamic-import keyword call,
+  // which avoids casting the ImportKeyword token (not typed as an Expression).
+  const importCall = ts.factory.createCallExpression(ts.factory.createIdentifier("import"), undefined, [ts.factory.createStringLiteral(importPath)]);
+  const thunk = ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), importCall);
+  // c.json(<thunk>)
+  return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("c"), ts.factory.createIdentifier("json")), undefined, [thunk]);
+}
+
+/**
+ * Inserts a new `.jsonValues()` entry `"<key>": c.json(() => import("<importPath>"))`
+ * into the record's object literal in a `.val.ts` module. `recordPath` is the
+ * path from the module source to the record (empty for a root record/router).
+ * Fails if the entry key already exists.
+ */
+function insertValJsonEntry(document, recordPath, key, importPath) {
+  return pipe(analyzeValModule(document), result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), result.flatMap(recordNode => {
+    if (!ts.isObjectLiteralExpression(recordNode)) {
+      return result.err(new PatchError("Cannot add jsonValues entry: record source is not an object literal"));
+    }
+    return pipe(findObjectPropertyAssignment(recordNode, key), result.flatMap(assignment => {
+      if (assignment) {
+        return result.err(new PatchError(`Cannot add jsonValues entry '${key}': it already exists`));
+      }
+      const property = ts.factory.createPropertyAssignment(isValidIdentifier(key) ? ts.factory.createIdentifier(key) : ts.factory.createStringLiteral(key), createValJsonReference(importPath));
+      return result.ok(insertAt(document, recordNode.properties, recordNode.properties.length, property));
+    }));
+  }));
+}
+
+/**
+ * Removes the `.jsonValues()` entry `"<key>"` from the record's object literal
+ * in a `.val.ts` module. `recordPath` is the path from the module source to the
+ * record (empty for a root record/router). Fails if the entry key is missing.
+ */
+function removeValJsonEntry(document, recordPath, key) {
+  return pipe(analyzeValModule(document), result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), result.flatMap(recordNode => {
+    if (!ts.isObjectLiteralExpression(recordNode)) {
+      return result.err(new PatchError("Cannot remove jsonValues entry: record source is not an object literal"));
+    }
+    return pipe(findObjectPropertyAssignment(recordNode, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError(`Cannot remove jsonValues entry '${key}': it does not exist`));
+      }
+      const [doc] = removeAt(document, recordNode.properties, recordNode.properties.indexOf(assignment));
+      return result.ok(doc);
+    }));
+  }));
+}
+function toExpression(value) {
+  if (typeof value === "string") {
+    // TODO: Use configuration/heuristics to determine use of single quote or double quote
+    return ts.factory.createStringLiteral(value);
+  } else if (typeof value === "number") {
+    // TODO: do we want to do something like this for very large numbers?
+    // if (value > Number.MAX_SAFE_INTEGER) {
+    //   return ts.factory.createBigIntLiteral(`${value}n`);
+    // }
+    // if (value < Number.MIN_SAFE_INTEGER) {
+    //   return ts.factory.createPrefixUnaryExpression(
+    //     ts.SyntaxKind.MinusToken,
+    //     ts.factory.createBigIntLiteral(`${value}n`),
+    //   );
+    // }
+    if (value < 0) {
+      return ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(Math.abs(value)));
+    }
+    return ts.factory.createNumericLiteral(value);
+  } else if (typeof value === "boolean") {
+    return value ? ts.factory.createTrue() : ts.factory.createFalse();
+  } else if (value === null) {
+    return ts.factory.createNull();
+  } else if (Array.isArray(value)) {
+    return ts.factory.createArrayLiteralExpression(value.map(toExpression));
+  } else if (typeof value === "object") {
+    return ts.factory.createObjectLiteralExpression(Object.entries(value)
+    // `patch_id` is injected server-side onto a media source whose bytes are
+    // not committed yet. It describes the draft, not the content, and a
+    // whole-object write built from the client's optimistic view would
+    // otherwise print it into the user's file.
+    .filter(([key]) => key !== "patch_id").map(([key, value]) => createPropertyAssignment(key, value)));
+  } else {
+    return ts.factory.createStringLiteral(value);
+  }
+}
+
+// TODO: Choose newline based on project settings/heuristics/system default?
+const newLine = ts.NewLineKind.LineFeed;
+// TODO: Handle indentation of printed code
+const printer = ts.createPrinter({
+  newLine: newLine
+  // neverAsciiEscape: true,
+});
+function replaceNodeValue(document, node, value) {
+  const replacementText = printer.printNode(ts.EmitHint.Unspecified, toExpression(value), document);
+  const span = ts.createTextSpanFromBounds(node.getStart(document, false), node.end);
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, replacementText.length)), node];
+}
+function isIndentation(s) {
+  for (let i = 0; i < s.length; ++i) {
+    const c = s.charAt(i);
+    if (c !== " " && c !== "\t") {
+      return false;
+    }
+  }
+  return true;
+}
+function newLineStr(kind) {
+  if (kind === ts.NewLineKind.CarriageReturnLineFeed) {
+    return "\r\n";
+  } else {
+    return "\n";
+  }
+}
+function getSeparator(document, neighbor) {
+  const startPos = neighbor.getStart(document, true);
+  const basis = document.getLineAndCharacterOfPosition(startPos);
+  const lineStartPos = document.getPositionOfLineAndCharacter(basis.line, 0);
+  const maybeIndentation = document.getText().substring(lineStartPos, startPos);
+  if (isIndentation(maybeIndentation)) {
+    return `,${newLineStr(newLine)}${maybeIndentation}`;
+  } else {
+    return `, `;
+  }
+}
+function insertAt(document, nodes, index, node) {
+  let span;
+  let replacementText;
+  if (nodes.length === 0) {
+    // Replace entire range of nodes
+    replacementText = printer.printNode(ts.EmitHint.Unspecified, node, document);
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length) {
+    // Insert after last node
+    const neighbor = nodes[nodes.length - 1];
+    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts.EmitHint.Unspecified, node, document)}`;
+    span = ts.createTextSpan(neighbor.end, 0);
+  } else {
+    // Insert before node
+    const neighbor = nodes[index];
+    replacementText = `${printer.printNode(ts.EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
+    span = ts.createTextSpan(neighbor.getStart(document, true), 0);
+  }
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts.textSpanEnd(span))}`;
+  return document.update(newText, ts.createTextChangeRange(span, replacementText.length));
+}
+function removeAt(document, nodes, index) {
+  const node = nodes[index];
+  let span;
+  if (nodes.length === 1) {
+    span = ts.createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length - 1) {
+    // Remove until previous node
+    const neighbor = nodes[index - 1];
+    span = ts.createTextSpanFromBounds(neighbor.end, node.end);
+  } else {
+    // Remove before next node
+    const neighbor = nodes[index + 1];
+    span = ts.createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
+  }
+  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts.textSpanEnd(span))}`;
+  return [document.update(newText, ts.createTextChangeRange(span, 0)), node];
+}
+function parseAndValidateArrayInsertIndex(key, nodes) {
+  if (key === "-") {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = validateInitializers(nodes);
+    if (err) {
+      return result.err(err);
+    }
+    return result.ok(nodes.length);
+  }
+  return pipe(parseAndValidateArrayIndex(key), result.flatMap(index => {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = validateInitializers(nodes.slice(0, index));
+    if (err) {
+      return result.err(err);
+    }
+    if (index > nodes.length) {
+      return result.err(new PatchError("Array index out of bounds"));
+    } else {
+      return result.ok(index);
+    }
+  }));
+}
+function parseAndValidateArrayInboundsIndex(key, nodes) {
+  return pipe(parseAndValidateArrayIndex(key), result.flatMap(index => {
+    // For in-bounds operations, all nodes up until and including the index
+    // must be valid initializers
+    const err = validateInitializers(nodes.slice(0, index + 1));
+    if (err) {
+      return result.err(err);
+    }
+    if (index >= nodes.length) {
+      return result.err(new PatchError("Array index out of bounds"));
+    } else {
+      return result.ok(index);
+    }
+  }));
+}
+function replaceInNode(document, node, key, value) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => replaceNodeValue(document, node.elements[index], value)));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError("Cannot replace object element which does not exist"));
+      }
+      return result.ok(assignment);
+    }), result.map(assignment => replaceNodeValue(document, assignment.initializer, value)));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot replace in non-object/array"));
+  }
+}
+function replaceAtPath(document, rootNode, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => replaceInNode(document, node, key, value)));
+  } else {
+    return result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function getFromNode(node, key) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => node.elements[index]));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.map(assignment => assignment === null || assignment === void 0 ? void 0 : assignment.initializer));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot access non-object/array"));
+  }
+}
+function getPointerFromPath(node, path) {
+  let targetNode = node;
+  let key = path[0];
+  for (let i = 0; i < path.length - 1; ++i, key = path[i]) {
+    const childNode = getFromNode(targetNode, key);
+    if (result.isErr(childNode)) {
+      return childNode;
+    }
+    if (childNode.value === undefined) {
+      return result.err(new PatchError(`Path refers to non-existing object/array: ${path.join("/")}`));
+    }
+    targetNode = childNode.value;
+  }
+  return result.ok([targetNode, key]);
+}
+function getAtPath(rootNode, path) {
+  return pipe(path, result.flatMapReduce((node, key) => pipe(getFromNode(node, key), result.filterOrElse(childNode => childNode !== undefined, () => new PatchError("Path refers to non-existing object/array"))), rootNode));
+}
+function removeFromNode(document, node, key) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInboundsIndex(key, node.elements), result.map(index => removeAt(document, node.elements, index)));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.flatMap(assignment => {
+      if (!assignment) {
+        return result.err(new PatchError("Cannot remove object element which does not exist"));
+      }
+      return result.ok(assignment);
+    }), result.map(assignment => [removeAt(document, node.properties, node.properties.indexOf(assignment))[0], assignment.initializer]));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot remove from non-object/array"));
+  }
+}
+function removeAtPath(document, rootNode, path) {
+  return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => removeFromNode(document, node, key)));
+}
+function addToNode(document, node, key, value) {
+  if (ts.isArrayLiteralExpression(node)) {
+    return pipe(parseAndValidateArrayInsertIndex(key, node.elements), result.map(index => [insertAt(document, node.elements, index, toExpression(value))]));
+  } else if (ts.isObjectLiteralExpression(node)) {
+    return pipe(findObjectPropertyAssignment(node, key), result.map(assignment => {
+      if (!assignment) {
+        return [insertAt(document, node.properties, node.properties.length, createPropertyAssignment(key, value))];
+      } else {
+        return replaceNodeValue(document, assignment.initializer, value);
+      }
+    }));
+  } else {
+    return result.err(shallowValidateExpression(node) ?? new PatchError("Cannot add to non-object/array"));
+  }
+}
+function addAtPath(document, rootNode, path, value) {
+  if (isNotRoot(path)) {
+    return pipe(getPointerFromPath(rootNode, path), result.flatMap(([node, key]) => addToNode(document, node, key, value)));
+  } else {
+    return result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function pickDocument([document]) {
+  return document;
+}
+class TSOps {
+  constructor(findRoot) {
+    this.findRoot = findRoot;
+  }
+  get(document, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => getAtPath(rootNode, path)), result.flatMap(evaluateExpression));
+  }
+  add(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => addAtPath(document, rootNode, path, value)), result.map(pickDocument));
+  }
+  remove(document, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => removeAtPath(document, rootNode, path)), result.map(pickDocument));
+  }
+  replace(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => replaceAtPath(document, rootNode, path, value)), result.map(pickDocument));
+  }
+  move(document, from, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => removeAtPath(document, rootNode, from)), result.flatMap(([document, removedNode]) => pipe(evaluateExpression(removedNode), result.map(removedValue => [document, removedValue]))), result.flatMap(([document, removedValue]) => pipe(document, this.findRoot, result.flatMap(root => addAtPath(document, root, path, removedValue)))), result.map(pickDocument));
+  }
+  copy(document, from, path) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => pipe(getAtPath(rootNode, from), result.flatMap(evaluateExpression), result.flatMap(value => addAtPath(document, rootNode, path, value)))), result.map(pickDocument));
+  }
+  test(document, path, value) {
+    return pipe(document, this.findRoot, result.flatMap(rootNode => getAtPath(rootNode, path)), result.flatMap(evaluateExpression), result.map(documentValue => deepEqual(value, documentValue)));
+  }
+}
+
+export { TSOps as T, insertValJsonEntry as i, removeValJsonEntry as r };