@valbuild/server 0.146.4 → 0.148.0

package/dist/jsonValuesModule-8ae503a8.cjs.dev.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+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__default["default"].isIdentifier(name) || ts__default["default"].isStringLiteral(name) || ts__default["default"].isNumericLiteral(name);
+}
+function validateObjectProperties(nodes) {
+  const errors = [];
+  for (const node of nodes) {
+    if (!ts__default["default"].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 fp.result.err(errors);
+  }
+  return fp.result.ok(nodes);
+}
+
+/**
+ * Validates that the expression is a JSON compatible type of expression without
+ * validating its children.
+ */
+function shallowValidateExpression(value) {
+  return ts__default["default"].isStringLiteralLike(value) || ts__default["default"].isNumericLiteral(value) || value.kind === ts__default["default"].SyntaxKind.TrueKeyword || value.kind === ts__default["default"].SyntaxKind.FalseKeyword || value.kind === ts__default["default"].SyntaxKind.NullKeyword || ts__default["default"].isArrayLiteralExpression(value) || ts__default["default"].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__default["default"].isStringLiteralLike(value)) {
+    return fp.result.ok(value.text);
+  } else if (ts__default["default"].isNumericLiteral(value)) {
+    return fp.result.ok(Number(value.text));
+  } else if (value.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
+    return fp.result.ok(true);
+  } else if (value.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+    return fp.result.ok(false);
+  } else if (value.kind === ts__default["default"].SyntaxKind.NullKeyword) {
+    return fp.result.ok(null);
+  } else if (ts__default["default"].isArrayLiteralExpression(value)) {
+    return fp.result.all(value.elements.map(evaluateExpression));
+  } else if (ts__default["default"].isObjectLiteralExpression(value)) {
+    return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => fp.pipe(assignments.map(assignment => fp.pipe(evaluateExpression(assignment.initializer), fp.result.map(value => [assignment.name.text, value]))), fp.result.all)), fp.result.map(Object.fromEntries));
+  } else {
+    return fp.result.err(new ValSyntaxError("Expression must be a literal", value));
+  }
+}
+function findObjectPropertyAssignment(value, key) {
+  return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => {
+    const matchingAssignments = assignments.filter(assignment => assignment.name.text === key);
+    if (matchingAssignments.length === 0) return fp.result.ok(undefined);
+    if (matchingAssignments.length > 1) {
+      return fp.result.err(new ValSyntaxError(`Object key "${key}" is ambiguous`, value));
+    }
+    const [assignment] = matchingAssignments;
+    return fp.result.ok(assignment);
+  }));
+}
+function validateInitializers(nodes) {
+  for (const node of nodes) {
+    if (ts__default["default"].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__default["default"].isPropertyAccessExpression(currentNode)) {
+      return false;
+    }
+    if (!ts__default["default"].isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+      return false;
+    }
+    currentNode = currentNode.expression;
+  }
+  return ts__default["default"].isIdentifier(currentNode) && currentNode.text === path[0];
+}
+function validateArguments(node, validators) {
+  return fp.result.allV([node.arguments.length === validators.length ? fp.result.voidOk : fp.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__default["default"].isCallExpression(cDefine)) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
+  }
+  if (!isPath(cDefine.expression, ["c", "define"])) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be calling c.define", cDefine.expression));
+  }
+  return fp.pipe(validateArguments(cDefine, [id => {
+    // TODO: validate ID value here?
+    if (!ts__default["default"].isStringLiteralLike(id)) {
+      return fp.result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
+    }
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }]), fp.result.map(() => {
+    const [, schema, source] = cDefine.arguments;
+    return {
+      schema,
+      source
+    };
+  }));
+}
+function analyzeValModule(sourceFile) {
+  const analysis = sourceFile.forEachChild(node => {
+    if (ts__default["default"].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__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;
+}
+
+/**
+ * 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__default["default"].isObjectLiteralExpression(source)) {
+    return keys;
+  }
+  for (const prop of source.properties) {
+    if (!ts__default["default"].isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key !== null) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+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;
+}
+
+exports.analyzeJsonValuesEntries = analyzeJsonValuesEntries;
+exports.analyzeValModule = analyzeValModule;
+exports.evaluateExpression = evaluateExpression;
+exports.findObjectPropertyAssignment = findObjectPropertyAssignment;
+exports.flatMapErrors = flatMapErrors;
+exports.formatSyntaxError = formatSyntaxError;
+exports.formatSyntaxErrorTree = formatSyntaxErrorTree;
+exports.jsonValuesRecordKeys = jsonValuesRecordKeys;
+exports.shallowValidateExpression = shallowValidateExpression;
+exports.validateInitializers = validateInitializers;

package/dist/jsonValuesModule-d1bb8d8f.cjs.prod.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+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__default["default"].isIdentifier(name) || ts__default["default"].isStringLiteral(name) || ts__default["default"].isNumericLiteral(name);
+}
+function validateObjectProperties(nodes) {
+  const errors = [];
+  for (const node of nodes) {
+    if (!ts__default["default"].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 fp.result.err(errors);
+  }
+  return fp.result.ok(nodes);
+}
+
+/**
+ * Validates that the expression is a JSON compatible type of expression without
+ * validating its children.
+ */
+function shallowValidateExpression(value) {
+  return ts__default["default"].isStringLiteralLike(value) || ts__default["default"].isNumericLiteral(value) || value.kind === ts__default["default"].SyntaxKind.TrueKeyword || value.kind === ts__default["default"].SyntaxKind.FalseKeyword || value.kind === ts__default["default"].SyntaxKind.NullKeyword || ts__default["default"].isArrayLiteralExpression(value) || ts__default["default"].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__default["default"].isStringLiteralLike(value)) {
+    return fp.result.ok(value.text);
+  } else if (ts__default["default"].isNumericLiteral(value)) {
+    return fp.result.ok(Number(value.text));
+  } else if (value.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
+    return fp.result.ok(true);
+  } else if (value.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+    return fp.result.ok(false);
+  } else if (value.kind === ts__default["default"].SyntaxKind.NullKeyword) {
+    return fp.result.ok(null);
+  } else if (ts__default["default"].isArrayLiteralExpression(value)) {
+    return fp.result.all(value.elements.map(evaluateExpression));
+  } else if (ts__default["default"].isObjectLiteralExpression(value)) {
+    return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => fp.pipe(assignments.map(assignment => fp.pipe(evaluateExpression(assignment.initializer), fp.result.map(value => [assignment.name.text, value]))), fp.result.all)), fp.result.map(Object.fromEntries));
+  } else {
+    return fp.result.err(new ValSyntaxError("Expression must be a literal", value));
+  }
+}
+function findObjectPropertyAssignment(value, key) {
+  return fp.pipe(validateObjectProperties(value.properties), fp.result.flatMap(assignments => {
+    const matchingAssignments = assignments.filter(assignment => assignment.name.text === key);
+    if (matchingAssignments.length === 0) return fp.result.ok(undefined);
+    if (matchingAssignments.length > 1) {
+      return fp.result.err(new ValSyntaxError(`Object key "${key}" is ambiguous`, value));
+    }
+    const [assignment] = matchingAssignments;
+    return fp.result.ok(assignment);
+  }));
+}
+function validateInitializers(nodes) {
+  for (const node of nodes) {
+    if (ts__default["default"].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__default["default"].isPropertyAccessExpression(currentNode)) {
+      return false;
+    }
+    if (!ts__default["default"].isIdentifier(currentNode.name) || currentNode.name.text !== name) {
+      return false;
+    }
+    currentNode = currentNode.expression;
+  }
+  return ts__default["default"].isIdentifier(currentNode) && currentNode.text === path[0];
+}
+function validateArguments(node, validators) {
+  return fp.result.allV([node.arguments.length === validators.length ? fp.result.voidOk : fp.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__default["default"].isCallExpression(cDefine)) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be a call expression", cDefine));
+  }
+  if (!isPath(cDefine.expression, ["c", "define"])) {
+    return fp.result.err(new ValSyntaxError("Expected default expression to be calling c.define", cDefine.expression));
+  }
+  return fp.pipe(validateArguments(cDefine, [id => {
+    // TODO: validate ID value here?
+    if (!ts__default["default"].isStringLiteralLike(id)) {
+      return fp.result.err(new ValSyntaxError("Expected first argument to c.define to be a string literal", id));
+    }
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }, () => {
+    return fp.result.voidOk;
+  }]), fp.result.map(() => {
+    const [, schema, source] = cDefine.arguments;
+    return {
+      schema,
+      source
+    };
+  }));
+}
+function analyzeValModule(sourceFile) {
+  const analysis = sourceFile.forEachChild(node => {
+    if (ts__default["default"].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__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;
+}
+
+/**
+ * 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__default["default"].isObjectLiteralExpression(source)) {
+    return keys;
+  }
+  for (const prop of source.properties) {
+    if (!ts__default["default"].isPropertyAssignment(prop)) {
+      continue;
+    }
+    const key = getPropertyKey(prop.name);
+    if (key !== null) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+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;
+}
+
+exports.analyzeJsonValuesEntries = analyzeJsonValuesEntries;
+exports.analyzeValModule = analyzeValModule;
+exports.evaluateExpression = evaluateExpression;
+exports.findObjectPropertyAssignment = findObjectPropertyAssignment;
+exports.flatMapErrors = flatMapErrors;
+exports.formatSyntaxError = formatSyntaxError;
+exports.formatSyntaxErrorTree = formatSyntaxErrorTree;
+exports.jsonValuesRecordKeys = jsonValuesRecordKeys;
+exports.shallowValidateExpression = shallowValidateExpression;
+exports.validateInitializers = validateInitializers;