@base44-preview/vite-plugin 0.2.27-pr.41.77be9cb → 0.2.27-pr.43.93e5e43

package/src/processors/collection-reference-field-processor.ts

@@ -0,0 +1,225 @@
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
+import {
+  DATA_COLLECTION_FIELD_REFERENCE,
+  DATA_COLLECTION_REFERENCE,
+} from "../consts.js";
+import {
+  JSXAttributeUtils,
+  ExpressionAnalysisUtils,
+  TypeCheckUtils,
+} from "./shared-utils.js";
+
+export class ReferenceFieldProcessor {
+  private attributeUtils: JSXAttributeUtils;
+  private expressionUtils: ExpressionAnalysisUtils;
+  private typeCheckUtils: TypeCheckUtils;
+
+  constructor(private types: typeof t) {
+    this.attributeUtils = new JSXAttributeUtils(types);
+    this.expressionUtils = new ExpressionAnalysisUtils(types);
+    this.typeCheckUtils = new TypeCheckUtils(types);
+  }
+
+  process(path: NodePath<t.JSXOpeningElement>): void {
+    if (
+      this.attributeUtils.hasAttribute(path, DATA_COLLECTION_FIELD_REFERENCE)
+    ) {
+      return;
+    }
+
+    if (
+      this.isReturnedFromReferenceMap(path) ||
+      this.isInsideReferenceLogicalExpression(path) ||
+      this.isInReferencePropertyMapChain(path)
+    ) {
+      this.attributeUtils.addStringAttribute(
+        path,
+        DATA_COLLECTION_FIELD_REFERENCE,
+        "true"
+      );
+    }
+  }
+
+  /**
+   * Strategy A: Element is the direct return of a .map() callback
+   * whose array is a reference variable (initialized via type-check pattern).
+   */
+  private isReturnedFromReferenceMap(
+    path: NodePath<t.JSXOpeningElement>
+  ): boolean {
+    const jsxElement = path.parentPath;
+    if (!jsxElement?.isJSXElement()) return false;
+
+    const parent = jsxElement.parentPath;
+    if (!parent) return false;
+
+    const callbackFn = this.findEnclosingMapCallback(parent);
+    if (!callbackFn) return false;
+
+    const mapCall = callbackFn.parentPath;
+    if (!mapCall?.isCallExpression()) return false;
+
+    const callee = mapCall.get("callee");
+    if (!callee.isMemberExpression()) return false;
+
+    const arrayObj = callee.get("object") as NodePath<t.Expression>;
+    return this.isReferenceArray(arrayObj);
+  }
+
+  /**
+   * Strategy B: Element is inside a && expression where the left operand
+   * references a field name that appears in an ancestor's data-collection-reference.
+   */
+  private isInsideReferenceLogicalExpression(
+    path: NodePath<t.JSXOpeningElement>
+  ): boolean {
+    const jsxElement = path.parentPath;
+    if (!jsxElement?.isJSXElement()) return false;
+
+    const logicalParent = jsxElement.parentPath;
+    if (!logicalParent?.isLogicalExpression()) return false;
+    if (logicalParent.node.operator !== "&&") return false;
+
+    const left = logicalParent.node.left;
+    const fieldName = this.extractFieldNameFromExpression(left as t.Expression);
+    if (!fieldName) return false;
+
+    return this.isFieldInAncestorReference(path, fieldName);
+  }
+
+  /**
+   * Strategy C: Element is inside a .map() chain on a reference property.
+   * e.g. item.relatedProducts.map(...) or item.relatedProducts.filter(...).map(...)
+   */
+  private isInReferencePropertyMapChain(
+    path: NodePath<t.JSXOpeningElement>
+  ): boolean {
+    const jsxElement = path.parentPath;
+    if (!jsxElement?.isJSXElement()) return false;
+
+    let current: NodePath | null = jsxElement;
+    while (current) {
+      if (current.isCallExpression()) {
+        const callee = current.get("callee");
+        if (callee.isMemberExpression()) {
+          const fieldName = this.extractReferenceFieldFromMapChain(callee);
+          if (fieldName && this.isFieldInAncestorReference(path, fieldName)) {
+            return true;
+          }
+        }
+      }
+      current = current.parentPath;
+    }
+
+    return false;
+  }
+
+  private findEnclosingMapCallback(
+    path: NodePath
+  ): NodePath<t.Function> | null {
+    let current: NodePath | null = path;
+    while (current) {
+      if (current.isArrowFunctionExpression() || current.isFunctionExpression()) {
+        const parent = current.parentPath;
+        if (parent?.isCallExpression()) {
+          const callee = parent.get("callee");
+          if (callee.isMemberExpression()) {
+            const prop = callee.get("property") as NodePath;
+            if (
+              prop.isIdentifier() &&
+              (prop.node.name === "map" || prop.node.name === "flatMap")
+            ) {
+              return current as NodePath<t.Function>;
+            }
+          }
+        }
+      }
+      current = current.parentPath;
+    }
+    return null;
+  }
+
+  private isReferenceArray(path: NodePath<t.Expression>): boolean {
+    if (!path.isIdentifier()) return false;
+
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding?.path.isVariableDeclarator()) return false;
+
+    const init = binding.path.get("init");
+    if (!init.isConditionalExpression()) return false;
+
+    const test = init.node.test;
+    return this.typeCheckUtils.isReferenceTypeCheck(test as t.Expression);
+  }
+
+  private extractFieldNameFromExpression(
+    node: t.Expression
+  ): string | null {
+    if (this.types.isMemberExpression(node)) {
+      const prop = node.property;
+      if (this.types.isIdentifier(prop)) return prop.name;
+    }
+    if (this.types.isOptionalMemberExpression(node)) {
+      const prop = node.property;
+      if (this.types.isIdentifier(prop)) return prop.name;
+    }
+    return null;
+  }
+
+  private isFieldInAncestorReference(
+    path: NodePath,
+    fieldName: string
+  ): boolean {
+    const ancestor = this.attributeUtils.findAncestorWithAttribute(
+      path,
+      DATA_COLLECTION_REFERENCE
+    );
+    if (!ancestor) return false;
+
+    const refValue = this.attributeUtils.getAttributeStringValue(
+      ancestor,
+      DATA_COLLECTION_REFERENCE
+    );
+    if (!refValue) return false;
+
+    const references = refValue.split(",").map((r) => r.trim());
+    return references.includes(fieldName);
+  }
+
+  private extractReferenceFieldFromMapChain(
+    callee: NodePath<t.MemberExpression>
+  ): string | null {
+    const prop = callee.get("property") as NodePath;
+    if (!prop.isIdentifier()) return null;
+
+    const methodName = prop.node.name;
+    const obj = callee.get("object") as NodePath<t.Expression>;
+
+    if (methodName === "map" || methodName === "flatMap") {
+      if (obj.isMemberExpression()) {
+        const fieldProp = obj.get("property") as NodePath;
+        if (fieldProp.isIdentifier()) return fieldProp.node.name;
+      }
+    }
+
+    if (methodName === "map" || methodName === "flatMap") {
+      if (obj.isCallExpression()) {
+        const innerCallee = obj.get("callee");
+        if (innerCallee.isMemberExpression()) {
+          return this.extractReferenceFieldFromMapChain(innerCallee);
+        }
+      }
+    }
+
+    if (
+      ["filter", "sort", "slice"].includes(methodName) &&
+      obj.isMemberExpression()
+    ) {
+      const fieldProp = obj.get("property") as NodePath;
+      if (fieldProp.isIdentifier()) return fieldProp.node.name;
+    }
+
+    return null;
+  }
+}