jsxpression 0.1.0

package/src/analyze/data/utils.ts

@@ -0,0 +1,329 @@
+import type { MemberExpression, Program } from "acorn";
+import {
+  isAllowedOnArray,
+  isAllowedOnString,
+  getAvailableArrayMembers,
+  getAvailableStringMembers,
+} from "../../builtins";
+import { Schema, ArrayPropertySchema, PropertySchema } from "../../schema";
+import { AnalysisReport } from "../analysis-report";
+import { getNodeRange } from "../utils";
+import { ValidationContext } from "../validation-context";
+
+export function isSimpleDataAccess(node: MemberExpression): boolean {
+  if (node.computed) {
+    return node.property.type === "Literal" && typeof node.property.value === "number";
+  }
+  if (node.property.type !== "Identifier") {
+    return false;
+  }
+
+  let current: MemberExpression["object"] = node.object;
+
+  while (current) {
+    if (current.type === "Identifier") {
+      return current.name === "data";
+    }
+
+    if (current.type === "MemberExpression") {
+      if (current.computed) {
+        if (!(current.property.type === "Literal" && typeof current.property.value === "number")) {
+          return false;
+        }
+      } else if (current.property.type !== "Identifier") {
+        return false;
+      }
+      current = current.object;
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+export function extractPath(node: MemberExpression): string[] {
+  const path: string[] = [];
+
+  if (node.property.type === "Identifier") {
+    path.unshift(node.property.name);
+  }
+
+  let current: MemberExpression["object"] = node.object;
+
+  while (current) {
+    if (current.type === "Identifier") {
+      path.unshift(current.name);
+      break;
+    }
+
+    if (current.type === "MemberExpression") {
+      if (current.property.type === "Identifier") {
+        path.unshift(current.property.name);
+      }
+      current = current.object;
+    } else {
+      break;
+    }
+  }
+
+  return path;
+}
+
+export function getParentNode(targetNode: any, ast: Program): any | null {
+  let parent: any = null;
+
+  function traverseForParent(node: any, currentParent: any = null): void {
+    if (node === targetNode) {
+      parent = currentParent;
+      return;
+    }
+
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          value.forEach((child) => {
+            if (child && typeof child === "object" && child.type) {
+              traverseForParent(child, node);
+            }
+          });
+        } else if (value.type) {
+          traverseForParent(value, node);
+        }
+      }
+    }
+  }
+
+  traverseForParent(ast);
+  return parent;
+}
+
+export function getAvailablePropsAtPath(path: string[], depth: number, schemaData: any): string[] {
+  if (!schemaData || depth < 0) {
+    return schemaData ? Object.keys(schemaData) : [];
+  }
+
+  if (depth === 0) {
+    return Object.keys(schemaData);
+  }
+
+  let current = schemaData[path[0]];
+
+  for (let i = 1; i <= depth; i++) {
+    if (!current || current.type !== "object" || !current.shape) {
+      return [];
+    }
+    current = current.shape[path[i]];
+  }
+
+  if (current && current.type === "object" && current.shape) {
+    return Object.keys(current.shape);
+  }
+
+  return [];
+}
+
+export function validateSchemaPath(
+  path: string[],
+  schema: Schema,
+  analysisReport: AnalysisReport,
+  node: MemberExpression,
+  validationContext: ValidationContext
+): void {
+  const schemaData = schema.data;
+  if (!schemaData || path.length === 0) {
+    analysisReport.addIssue(
+      "INVALID_DATA_ACCESS",
+      "Invalid data access - no schema data available",
+      getNodeRange(node),
+      validationContext.getSnapshot(),
+      schemaData ? Object.keys(schemaData) : undefined
+    );
+    return;
+  }
+
+  let current = schemaData[path[0]];
+
+  if (!current) {
+    analysisReport.addIssue(
+      "INVALID_DATA_ACCESS",
+      `Property 'data.${path[0]}' does not exist in schema`,
+      getNodeRange(node),
+      validationContext.getSnapshot(),
+      Object.keys(schemaData)
+    );
+    return;
+  }
+
+  const elementAccessFlags = getElementAccessFlags(node, path.length);
+
+  for (let i = 1; i < path.length; i++) {
+    const prop = path[i];
+    const isElementAccess = elementAccessFlags[i];
+
+    if (current.type === "array") {
+      if (!isElementAccess) {
+        if (isAllowedOnArray(prop)) {
+          return;
+        }
+
+        const accessedPath = ["data", ...path.slice(0, i), prop].join(".");
+        analysisReport.addIssue(
+          "INVALID_DATA_ACCESS",
+          `Property '${accessedPath}' does not exist on array type`,
+          getNodeRange(node),
+          validationContext.getSnapshot(),
+          getAvailableArrayMembers()
+        );
+        return;
+      }
+
+      const elementType = current.shape || null;
+
+      if (!elementType) {
+        analysisReport.addIssue(
+          "INVALID_DATA_ACCESS",
+          `Cannot access property '${prop}' on unknown array element type`,
+          getNodeRange(node),
+          validationContext.getSnapshot(),
+          getAvailableArrayMembers()
+        );
+        return;
+      }
+
+      if (elementType.type === "object" && elementType.shape) {
+        const next = elementType.shape[prop];
+
+        if (!next) {
+          const paths = path.slice(0, i + 1);
+          const suggestions = Object.keys(elementType.shape);
+
+          analysisReport.addIssue(
+            "INVALID_DATA_ACCESS",
+            `Property 'data.${paths.join(".")}' does not exist in schema`,
+            getNodeRange(node),
+            validationContext.getSnapshot(),
+            suggestions
+          );
+          return;
+        }
+
+        current = next;
+        continue;
+      }
+
+      if (elementType.type === "array") {
+        if (isAllowedOnArray(prop)) {
+          return;
+        }
+
+        const accessedPath = ["data", ...path.slice(0, i), prop].join(".");
+        analysisReport.addIssue(
+          "INVALID_DATA_ACCESS",
+          `Property '${accessedPath}' does not exist on array type`,
+          getNodeRange(node),
+          validationContext.getSnapshot(),
+          getAvailableArrayMembers()
+        );
+        return;
+      }
+
+      if (elementType.type === "string") {
+        if (isAllowedOnString(prop)) {
+          return;
+        }
+
+        const accessedPath = ["data", ...path.slice(0, i), prop].join(".");
+        analysisReport.addIssue(
+          "INVALID_DATA_ACCESS",
+          `Property '${accessedPath}' does not exist on string type`,
+          getNodeRange(node),
+          validationContext.getSnapshot(),
+          getAvailableStringMembers()
+        );
+        return;
+      }
+
+      analysisReport.addIssue(
+        "INVALID_DATA_ACCESS",
+        `Cannot access property '${prop}' on ${elementType.type || "undefined"} type array element`,
+        getNodeRange(node),
+        validationContext.getSnapshot()
+      );
+      return;
+    }
+
+    if (current.type === "string") {
+      if (isAllowedOnString(prop)) {
+        return;
+      }
+
+      const accessedPath = ["data", ...path.slice(0, i), prop].join(".");
+      analysisReport.addIssue(
+        "INVALID_DATA_ACCESS",
+        `Property '${accessedPath}' does not exist on string type`,
+        getNodeRange(node),
+        validationContext.getSnapshot(),
+        getAvailableStringMembers()
+      );
+      return;
+    }
+
+    if (current.type !== "object" || !current.shape) {
+      analysisReport.addIssue(
+        "INVALID_DATA_ACCESS",
+        `Cannot access property '${prop}' on ${current.type || "undefined"} type`,
+        getNodeRange(node),
+        validationContext.getSnapshot()
+      );
+      return;
+    }
+
+    current = current.shape[prop];
+
+    if (!current) {
+      const availableProps = getAvailablePropsAtPath(path, i - 1, schemaData);
+      const paths = path.slice(0, i + 1);
+
+      analysisReport.addIssue(
+        "INVALID_DATA_ACCESS",
+        `Property 'data.${paths.join(".")}' does not exist in schema`,
+        getNodeRange(node),
+        validationContext.getSnapshot(),
+        availableProps
+      );
+    }
+  }
+}
+
+function getElementAccessFlags(node: MemberExpression, pathLength: number): boolean[] {
+  const flags = Array(pathLength).fill(false);
+  const segments: Array<{ property: any; computed: boolean }> = [];
+
+  let current: any = node;
+  while (current && current.type === "MemberExpression") {
+    segments.unshift({ property: current.property, computed: current.computed });
+    current = current.object;
+  }
+
+  let schemaIndex = -1;
+  let lastWasComputedNumeric = false;
+
+  for (const segment of segments) {
+    if (segment.property?.type === "Identifier") {
+      schemaIndex += 1;
+      if (schemaIndex < pathLength) {
+        flags[schemaIndex] = lastWasComputedNumeric;
+      }
+    }
+
+    if (segment.computed && segment.property?.type === "Literal" && typeof segment.property.value === "number") {
+      lastWasComputedNumeric = true;
+    } else {
+      lastWasComputedNumeric = false;
+    }
+  }
+
+  return flags;
+}

package/src/analyze/index.ts

@@ -0,0 +1,3 @@
+export { analyze } from "./analyze";
+export { AnalysisError } from "./analysis-error";
+export { AnalysisReport } from "./analysis-report";

package/src/analyze/jsx/analyze.ts

@@ -0,0 +1,17 @@
+import { Program } from "acorn";
+import { Schema } from "../../schema";
+import { AnalysisReport } from "../analysis-report";
+import { ValidationContext } from "../validation-context";
+import { analyzeElementAttributes } from "./element-attributes";
+import { analyzeElementChildren } from "./element-children";
+import { analyzeElementTags } from "./element-tags";
+
+export function analyzeJsx(ast: Program, schema: Schema): AnalysisReport {
+  const validationContext = new ValidationContext();
+
+  return new AnalysisReport().merge(
+    analyzeElementTags(ast, schema, validationContext),
+    analyzeElementAttributes(ast, schema, validationContext),
+    analyzeElementChildren(ast, schema, validationContext)
+  );
+}

package/src/analyze/jsx/element-attributes.ts

@@ -0,0 +1,143 @@
+import type { Program } from "acorn";
+import { traverse } from "../../traverse";
+import {
+  type Schema,
+  isAttributeAllowed,
+  getAllowedAttributes,
+  getRequiredAttributes,
+  getAttributeSchema,
+  getEnumValues,
+} from "../../schema";
+import { isJsxAttribute, isJsxExpressionContainer, type JSXAttribute } from "../../jsx";
+import { ValidationContext } from "../validation-context";
+import { AnalysisReport } from "../analysis-report";
+
+import { getNodeRange, getAttributeSimilarityMatchers, getBestSimilarityMatcherSuggestion } from "../utils";
+
+export function analyzeElementAttributes(
+  ast: Program,
+  schema: Schema,
+  validationContext: ValidationContext
+): AnalysisReport {
+  const analysisReport = new AnalysisReport();
+
+  traverse(ast, {
+    JSXElement(node) {
+      const tagName = node.openingElement.name.name;
+
+      validationContext.enterElement(tagName);
+      const currentContext = validationContext.getSnapshot();
+
+      const allowedAttributes = getAllowedAttributes(schema, tagName);
+      const requiredAttributes = getRequiredAttributes(schema, tagName);
+
+      for (const attribute of node.openingElement.attributes) {
+        if (!isJsxAttribute(attribute)) {
+          continue;
+        }
+
+        const attributeName = attribute.name.name;
+        const range = getNodeRange(attribute);
+
+        if (!isAttributeAllowed(schema, tagName, attributeName)) {
+          const suggestions = getAttributeSimilarityMatchers(attributeName, allowedAttributes);
+          const suggestionMatch = getBestSimilarityMatcherSuggestion(attributeName, allowedAttributes);
+
+          let message = `Attribute "${attributeName}" not allowed on <${tagName}>`;
+
+          if (suggestionMatch) {
+            message += `. Did you mean "${suggestionMatch}"?`;
+          } else if (allowedAttributes.length > 0) {
+            const displayAttrs = allowedAttributes.slice(0, 5);
+            message += `. Available attributes: ${displayAttrs.join(", ")}`;
+            if (allowedAttributes.length > 5) {
+              message += ` (and ${allowedAttributes.length - 5} more)`;
+            }
+          }
+
+          analysisReport.addIssue(
+            "INVALID_ATTRIBUTE",
+            message,
+            range,
+            currentContext,
+            suggestions.map((suggestion) => suggestion.suggestion)
+          );
+          continue;
+        }
+
+        const attributeSchema = getAttributeSchema(schema, tagName, attributeName);
+        const enumValues = attributeSchema ? getEnumValues(attributeSchema) : undefined;
+
+        if (enumValues && enumValues.length > 0) {
+          const literalValue = getAttributeLiteralValue(attribute);
+
+          if (isEnumComparableValue(literalValue) && !enumValues.includes(literalValue)) {
+            const stringEnumValues = enumValues.map((value) => String(value));
+            const suggestionMatch = getBestSimilarityMatcherSuggestion(String(literalValue), stringEnumValues);
+
+            let message = `Value ${JSON.stringify(
+              literalValue
+            )} is not allowed for attribute "${attributeName}" on <${tagName}>`;
+
+            if (suggestionMatch) {
+              message += `. Did you mean "${suggestionMatch}"?`;
+            } else {
+              message += `. Allowed values: ${enumValues.map((value) => JSON.stringify(value)).join(", ")}`;
+            }
+
+            analysisReport.addIssue(
+              "INVALID_ATTRIBUTE_VALUE",
+              message,
+              range,
+              currentContext,
+              suggestionMatch ? [suggestionMatch] : stringEnumValues
+            );
+          }
+        }
+      }
+
+      // Check for missing required attributes
+      const providedAttributes = node.openingElement.attributes.filter(isJsxAttribute).map((attr) => attr.name.name);
+
+      for (const requiredAttribute of requiredAttributes) {
+        if (!providedAttributes.includes(requiredAttribute)) {
+          analysisReport.addIssue(
+            "MISSING_REQUIRED_ATTRIBUTE",
+            `Required attribute "${requiredAttribute}" missing on <${tagName}>`,
+            getNodeRange(node.openingElement),
+            currentContext,
+            [requiredAttribute]
+          );
+        }
+      }
+
+      validationContext.exitElement();
+    },
+  });
+
+  return analysisReport;
+}
+
+function isEnumComparableValue(value: unknown): value is string | number | boolean {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function getAttributeLiteralValue(attribute: JSXAttribute): string | number | boolean | null | undefined {
+  if (!attribute.value) {
+    return true;
+  }
+
+  if (attribute.value.type === "Literal") {
+    return attribute.value.value as string | number | boolean | null | undefined;
+  }
+
+  if (isJsxExpressionContainer(attribute.value)) {
+    const expression = attribute.value.expression as { type?: string; value?: unknown };
+
+    if (expression?.type === "Literal") {
+      return expression.value as string | number | boolean | null | undefined;
+    }
+  }
+
+  return undefined;
+}

package/src/analyze/jsx/element-children.ts

@@ -0,0 +1,97 @@
+import type { Program } from "acorn";
+import { traverse } from "../../traverse";
+import { type Schema, getAllowedChildren, isSelfClosing } from "../../schema";
+import { isJsxElement, isJsxFragment, isJsxText, isJsxLeafNode } from "../../jsx";
+import { ValidationContext } from "../validation-context";
+import { AnalysisReport } from "../analysis-report";
+import { getNodeRange, getElementSimilarityMatchers, getBestSimilarityMatcherSuggestion } from "../utils";
+
+export function analyzeElementChildren(
+  ast: Program,
+  schema: Schema,
+  validationContext: ValidationContext
+): AnalysisReport {
+  const analysisReport = new AnalysisReport();
+
+  traverse(ast, {
+    JSXElement(node) {
+      const parentTag = node.openingElement.name.name;
+
+      validationContext.enterElement(parentTag);
+
+      const currentContext = validationContext.getSnapshot();
+
+      const allowedChildren = getAllowedChildren(schema, parentTag);
+
+      if (!allowedChildren) {
+        validationContext.exitElement();
+        return;
+      }
+
+      if (isSelfClosing(schema, parentTag) && node.children.length > 0) {
+        const hasNonWhitespaceContent = node.children.some((child) => {
+          if (isJsxText(child)) {
+            return child.value.trim().length > 0;
+          }
+          return !isJsxLeafNode(child) || !isJsxText(child);
+        });
+
+        if (hasNonWhitespaceContent) {
+          const firstMeaningfulChild = node.children.find((child) => {
+            if (isJsxText(child)) {
+              return child.value.trim().length > 0;
+            }
+            return true;
+          });
+
+          analysisReport.addIssue(
+            "SELF_CLOSING_WITH_CHILDREN",
+            `Element <${parentTag}> cannot have children. It is self-closing.`,
+            getNodeRange(firstMeaningfulChild || node.children[0]),
+            currentContext
+          );
+        }
+      }
+
+      for (const child of node.children) {
+        if (isJsxElement(child)) {
+          const childTag = child.openingElement.name.name;
+
+          if (!allowedChildren.includes(childTag)) {
+            const elementSimilarityMatchers = getElementSimilarityMatchers(childTag, allowedChildren);
+            const bestSimilarityMatcherSuggestion = getBestSimilarityMatcherSuggestion(childTag, allowedChildren);
+
+            let message = `Element <${childTag}> not allowed in <${parentTag}>`;
+
+            if (bestSimilarityMatcherSuggestion) {
+              message += `. Did you mean <${bestSimilarityMatcherSuggestion}>?`;
+            }
+
+            message += `. Allowed children: ${allowedChildren.join(", ")}`;
+
+            analysisReport.addIssue(
+              "INVALID_CHILD_ELEMENT",
+              message,
+              getNodeRange(child),
+              currentContext,
+              elementSimilarityMatchers.map((similarityMatcher) => similarityMatcher.suggestion)
+            );
+          }
+        } else if (isJsxFragment(child)) {
+          // TODO: Recursively validate fragment children
+          // For now, we allow fragments but should add more specific validation in the future
+        } else if (isJsxText(child)) {
+          const hasContent = child.value.trim().length > 0;
+          if (!hasContent) {
+            // Allow whitespace-only text nodes (very common in JSX formatting)
+            continue;
+          }
+        }
+      }
+
+      validationContext.exitElement();
+    },
+  });
+
+  return analysisReport;
+}

package/src/analyze/jsx/element-tags.ts

@@ -0,0 +1,55 @@
+import type { Program } from "acorn";
+import { traverse } from "../../traverse";
+import { type Schema, isElementAllowed, getAllElements } from "../../schema";
+import { ValidationContext } from "../validation-context";
+import { AnalysisReport } from "../analysis-report";
+import { getNodeRange, getElementSimilarityMatchers, getBestSimilarityMatcherSuggestion } from "../utils";
+
+export function analyzeElementTags(ast: Program, schema: Schema, validationContext: ValidationContext): AnalysisReport {
+  const analysisReport = new AnalysisReport();
+
+  traverse(ast, {
+    JSXElement(node) {
+      const tagName = node.openingElement.name.name;
+
+      validationContext.enterElement(tagName);
+
+      const snapshot = validationContext.getSnapshot();
+      const range = getNodeRange(node);
+
+      if (!isElementAllowed(schema, tagName)) {
+        const availableElements = getAllElements(schema);
+        const elementSimilarityMatchers = getElementSimilarityMatchers(tagName, availableElements);
+        const bestSuggestionMatch = getBestSimilarityMatcherSuggestion(tagName, availableElements);
+
+        let message = `Element <${tagName}> not allowed`;
+
+        if (snapshot.elements.length > 1) {
+          message += ` in ${validationContext.currentPath}`;
+        }
+
+        if (bestSuggestionMatch) {
+          message += `. Did you mean <${bestSuggestionMatch}>?`;
+        } else if (availableElements.length > 0) {
+          const displayElements = availableElements.slice(0, 5);
+          message += `. Available elements: ${displayElements.join(", ")}`;
+          if (availableElements.length > 5) {
+            message += ` (and ${availableElements.length - 5} more)`;
+          }
+        }
+
+        analysisReport.addIssue(
+          "INVALID_ELEMENT",
+          message,
+          range,
+          snapshot,
+          elementSimilarityMatchers.map((similarityMatcher) => similarityMatcher.suggestion)
+        );
+      }
+
+      validationContext.exitElement();
+    },
+  });
+
+  return analysisReport;
+}

package/src/analyze/jsx/index.ts

@@ -0,0 +1 @@
+export { analyzeJsx } from "./analyze";

package/src/analyze/security/analyze.ts

@@ -0,0 +1,21 @@
+import { Program } from "acorn";
+import { Schema } from "../../schema";
+import { AnalysisReport } from "../analysis-report";
+import { ValidationContext } from "../validation-context";
+import { analyzeCallExpressions } from "./call-expressions";
+import { analyzeDeclarations } from "./declarations";
+import { analyzeExpressions } from "./expressions";
+import { analyzeIdentifiers } from "./identifiers";
+import { analyzeMemberAccess } from "./member-access";
+
+export function analyzeSecurity(ast: Program, schema: Schema): AnalysisReport {
+  const validationContext = new ValidationContext();
+
+  return new AnalysisReport().merge(
+    analyzeDeclarations(ast, schema, validationContext),
+    analyzeIdentifiers(ast, schema, validationContext),
+    analyzeExpressions(ast, schema, validationContext),
+    analyzeMemberAccess(ast, schema, validationContext),
+    analyzeCallExpressions(ast, schema, validationContext)
+  );
+}