@base44-preview/vite-plugin 0.2.26-pr.43.e9195be → 0.2.27-pr.41.77be9cb

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

@@ -1,410 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type * as t from "@babel/types";
-import {
-  DATA_COLLECTION_ITEM_FIELD,
-  DATA_COLLECTION_ITEM_ID,
-  EXCLUDED_FIELDS,
-} from "../consts.js";
-import { JSXUtils } from "../jsx-utils.js";
-import {
-  JSXAttributeUtils,
-  ExpressionAnalysisUtils,
-  StaticValueUtils,
-} from "./shared-utils.js";
-
-export class DataItemFieldProcessor {
-  private attributeUtils: JSXAttributeUtils;
-  private expressionUtils: ExpressionAnalysisUtils;
-  private staticUtils: StaticValueUtils;
-
-  constructor(private types: typeof t) {
-    this.attributeUtils = new JSXAttributeUtils(types);
-    this.expressionUtils = new ExpressionAnalysisUtils(types);
-    this.staticUtils = new StaticValueUtils(types);
-  }
-
-  process(path: NodePath<t.JSXOpeningElement>): void {
-    if (this.attributeUtils.hasAttribute(path, DATA_COLLECTION_ITEM_FIELD)) {
-      return;
-    }
-
-    const jsxElement = path.parentPath;
-    if (!jsxElement?.isJSXElement()) return;
-
-    const result = this.extractFieldFromChildren(jsxElement);
-    if (!result) return;
-
-    this.attributeUtils.addStringAttribute(
-      path,
-      DATA_COLLECTION_ITEM_FIELD,
-      result.fieldPath
-    );
-
-    this.tryAddItemId(path, result.rootIdentifier, result.fieldPath);
-  }
-
-  private extractFieldFromChildren(
-    jsxElement: NodePath<t.JSXElement>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const children = jsxElement.get("children");
-
-    for (const child of children) {
-      const result = this.extractFieldFromChild(child);
-      if (result) return result;
-    }
-
-    return null;
-  }
-
-  private extractFieldFromChild(
-    child: NodePath
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    if (child.isJSXExpressionContainer()) {
-      return this.extractFromExpressionContainer(child);
-    }
-
-    if (child.isJSXElement()) {
-      return this.extractFromChildElement(child);
-    }
-
-    return null;
-  }
-
-  private extractFromExpressionContainer(
-    container: NodePath<t.JSXExpressionContainer>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const expression = container.get("expression");
-
-    if (expression.isJSXEmptyExpression()) return null;
-
-    const expr = expression as NodePath<t.Expression>;
-
-    if (expr.isMemberExpression() || expr.isOptionalMemberExpression()) {
-      return this.extractFromMemberExpression(expr);
-    }
-
-    if (expr.isLogicalExpression() && expr.node.operator === "&&") {
-      const left = expr.get("left") as NodePath<t.Expression>;
-      if (
-        left.isMemberExpression() ||
-        left.isOptionalMemberExpression()
-      ) {
-        return this.extractFromMemberExpression(left);
-      }
-    }
-
-    if (expr.isCallExpression()) {
-      const callee = expr.get("callee");
-      if (callee.isMemberExpression()) {
-        const obj = callee.get("object") as NodePath<t.Expression>;
-        if (obj.isMemberExpression() || obj.isOptionalMemberExpression()) {
-          return this.extractFromMemberExpression(obj);
-        }
-      }
-    }
-
-    if (expr.isIdentifier()) {
-      return this.extractFromSimpleIdentifier(expr);
-    }
-
-    return null;
-  }
-
-  private extractFromMemberExpression(
-    expr: NodePath<t.MemberExpression | t.OptionalMemberExpression>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const rootId = this.expressionUtils.extractRootIdentifier(
-      expr.node as t.Expression
-    );
-    if (!rootId) return null;
-
-    if (this.staticUtils.isDerivedFromStaticData(rootId.name, expr)) {
-      return null;
-    }
-
-    const parts = this.expressionUtils.collectMemberExpressionPath(
-      expr.node as t.Expression
-    );
-    if (parts.length < 2) return null;
-
-    const fieldParts = parts.slice(1);
-    const fieldPath = fieldParts.join(".");
-
-    if (EXCLUDED_FIELDS.includes(fieldPath)) return null;
-    if (fieldParts.some((p) => EXCLUDED_FIELDS.includes(p))) return null;
-
-    return { fieldPath, rootIdentifier: rootId };
-  }
-
-  private extractFromSimpleIdentifier(
-    expr: NodePath<t.Identifier>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const name = expr.node.name;
-    if (EXCLUDED_FIELDS.includes(name)) return null;
-    if (this.staticUtils.isDerivedFromStaticData(name, expr)) return null;
-
-    return { fieldPath: name, rootIdentifier: expr.node };
-  }
-
-  private extractFromChildElement(
-    child: NodePath<t.JSXElement>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const elementName = JSXUtils.getElementName(child.node.openingElement);
-    if (!elementName) return null;
-
-    if (elementName === "Image" || elementName === "img") {
-      return this.extractFromImageElement(child);
-    }
-
-    const logicalParent = child.parentPath;
-    if (logicalParent?.isJSXExpressionContainer()) {
-      const logicalExpr = logicalParent.parentPath;
-      if (logicalExpr?.isLogicalExpression()) {
-        return this.extractFromConditionalImage(child);
-      }
-    }
-
-    return null;
-  }
-
-  private extractFromImageElement(
-    imageElement: NodePath<t.JSXElement>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const openingElement = imageElement.get("openingElement");
-    const attrs = openingElement.node.attributes;
-
-    for (const attr of attrs) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        this.types.isJSXIdentifier(attr.name) &&
-        attr.name.name === "src"
-      ) {
-        if (
-          attr.value &&
-          this.types.isJSXExpressionContainer(attr.value) &&
-          this.types.isExpression(attr.value.expression) &&
-          !this.types.isJSXEmptyExpression(attr.value.expression)
-        ) {
-          const expr = attr.value.expression;
-          if (
-            this.types.isMemberExpression(expr) ||
-            this.types.isOptionalMemberExpression(expr)
-          ) {
-            const rootId = this.expressionUtils.extractRootIdentifier(expr);
-            if (!rootId) return null;
-
-            const parts = this.expressionUtils.collectMemberExpressionPath(expr);
-            if (parts.length < 2) return null;
-
-            const fieldPath = parts.slice(1).join(".");
-            if (EXCLUDED_FIELDS.includes(fieldPath)) return null;
-
-            return { fieldPath, rootIdentifier: rootId };
-          }
-        }
-      }
-    }
-
-    return null;
-  }
-
-  private extractFromConditionalImage(
-    child: NodePath<t.JSXElement>
-  ): { fieldPath: string; rootIdentifier: t.Identifier } | null {
-    const elementName = JSXUtils.getElementName(child.node.openingElement);
-    if (elementName === "Image" || elementName === "img") {
-      return this.extractFromImageElement(child);
-    }
-    return null;
-  }
-
-  private tryAddItemId(
-    path: NodePath<t.JSXOpeningElement>,
-    rootIdentifier: t.Identifier,
-    fieldPath: string
-  ): void {
-    if (this.attributeUtils.hasAttribute(path, DATA_COLLECTION_ITEM_ID)) {
-      return;
-    }
-
-    const idField = this.resolveIdFieldName(path);
-
-    // Simple identifier: {name} from ({ name, price }) => ...
-    // rootIdentifier IS the field value (a string), not an object with ._id/.id.
-    // We need to find the id field from sibling destructured params instead.
-    if (rootIdentifier.name === fieldPath) {
-      this.tryAddItemIdFromDestructuredParams(path, idField);
-      return;
-    }
-
-    // Member expression: {product.name} → product?.id or product?._id
-    const idExpr = this.types.optionalMemberExpression(
-      this.types.identifier(rootIdentifier.name),
-      this.types.identifier(idField),
-      false,
-      true
-    );
-
-    const binding = path.scope.getBinding(rootIdentifier.name);
-    if (!binding) {
-      this.tryAddItemIdFromParentComponent(path, rootIdentifier, idField);
-      return;
-    }
-
-    if (
-      binding.path.isVariableDeclarator() ||
-      binding.kind === "param"
-    ) {
-      this.attributeUtils.addExpressionAttribute(
-        path,
-        DATA_COLLECTION_ITEM_ID,
-        idExpr
-      );
-    }
-  }
-
-  /**
-   * Walk up the JSX tree to find a key attribute that accesses .id or ._id,
-   * returning the actual field name used. Falls back to "_id".
-   */
-  private resolveIdFieldName(
-    path: NodePath<t.JSXOpeningElement>
-  ): string {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isJSXElement()) {
-        const opening = current.get("openingElement");
-        const field = this.extractIdFieldFromKey(opening);
-        if (field) return field;
-      }
-      current = current.parentPath;
-    }
-    return "_id";
-  }
-
-  private extractIdFieldFromKey(
-    path: NodePath<t.JSXOpeningElement>
-  ): string | null {
-    for (const attr of path.node.attributes) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        this.types.isJSXIdentifier(attr.name) &&
-        attr.name.name === "key" &&
-        attr.value &&
-        this.types.isJSXExpressionContainer(attr.value)
-      ) {
-        const expr = attr.value.expression;
-        if (
-          this.types.isMemberExpression(expr) &&
-          this.types.isIdentifier(expr.property)
-        ) {
-          const name = expr.property.name;
-          if (name === "id" || name === "_id") return name;
-        }
-      }
-    }
-    return null;
-  }
-
-  /**
-   * For simple identifiers from destructured component props like ({ name, price }),
-   * find or inject the id field in the ObjectPattern so we can reference it directly.
-   */
-  private tryAddItemIdFromDestructuredParams(
-    path: NodePath<t.JSXOpeningElement>,
-    idField: string
-  ): void {
-    const fn = path.getFunctionParent();
-    if (!fn) return;
-
-    const params = fn.get("params");
-    for (const param of Array.isArray(params) ? params : [params]) {
-      if (!param.isObjectPattern()) continue;
-
-      // Check if the id field is already destructured
-      for (const prop of param.get("properties")) {
-        if (
-          prop.isObjectProperty() &&
-          this.types.isIdentifier(prop.node.key) &&
-          (prop.node.key.name === "id" || prop.node.key.name === "_id") &&
-          this.types.isIdentifier(prop.node.value)
-        ) {
-          this.attributeUtils.addExpressionAttribute(
-            path,
-            DATA_COLLECTION_ITEM_ID,
-            this.types.identifier(prop.node.value.name)
-          );
-          return;
-        }
-      }
-
-      // id field not destructured yet — inject it into the pattern
-      param.node.properties.push(
-        this.types.objectProperty(
-          this.types.identifier(idField),
-          this.types.identifier(idField),
-          false,
-          true
-        )
-      );
-      this.attributeUtils.addExpressionAttribute(
-        path,
-        DATA_COLLECTION_ITEM_ID,
-        this.types.identifier(idField)
-      );
-      return;
-    }
-  }
-
-  private tryAddItemIdFromParentComponent(
-    path: NodePath<t.JSXOpeningElement>,
-    rootIdentifier: t.Identifier,
-    idField: string
-  ): void {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isJSXElement()) {
-        const opening = current.get("openingElement");
-        const name = JSXUtils.getElementName(opening.node);
-        if (name && JSXUtils.isCustomComponent(name)) {
-          const keyAttr = this.findKeyWithId(opening);
-          if (keyAttr) {
-            const idExpr = this.types.optionalMemberExpression(
-              this.types.identifier(rootIdentifier.name),
-              this.types.identifier(idField),
-              false,
-              true
-            );
-            this.attributeUtils.addExpressionAttribute(
-              path,
-              DATA_COLLECTION_ITEM_ID,
-              idExpr
-            );
-            return;
-          }
-        }
-      }
-      current = current.parentPath;
-    }
-  }
-
-  private findKeyWithId(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    for (const attr of path.node.attributes) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        this.types.isJSXIdentifier(attr.name) &&
-        attr.name.name === "key" &&
-        attr.value &&
-        this.types.isJSXExpressionContainer(attr.value)
-      ) {
-        const expr = attr.value.expression;
-        if (this.types.isExpression(expr)) {
-          return this.expressionUtils.isIdAccess(expr);
-        }
-      }
-    }
-    return false;
-  }
-}

package/src/processors/collection-item-id-processor.ts

@@ -1,69 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type * as t from "@babel/types";
-import { DATA_COLLECTION_ITEM_ID } from "../consts.js";
-import {
-  JSXAttributeUtils,
-  ExpressionAnalysisUtils,
-} from "./shared-utils.js";
-
-export class DataItemIdProcessor {
-  private attributeUtils: JSXAttributeUtils;
-  private expressionUtils: ExpressionAnalysisUtils;
-
-  constructor(private types: typeof t) {
-    this.attributeUtils = new JSXAttributeUtils(types);
-    this.expressionUtils = new ExpressionAnalysisUtils(types);
-  }
-
-  process(path: NodePath<t.JSXOpeningElement>): void {
-    if (this.attributeUtils.hasAttribute(path, DATA_COLLECTION_ITEM_ID)) {
-      return;
-    }
-
-    const keyAttr = this.findKeyAttribute(path);
-    if (!keyAttr) return;
-
-    const expression = this.extractKeyExpression(keyAttr);
-    if (!expression) return;
-
-    if (!this.expressionUtils.isIdAccess(expression)) return;
-
-    const optionalExpr = this.types.isMemberExpression(expression)
-      ? this.expressionUtils.createOptionalChainExpression(expression)
-      : expression;
-
-    this.attributeUtils.addExpressionAttribute(
-      path,
-      DATA_COLLECTION_ITEM_ID,
-      optionalExpr
-    );
-  }
-
-  private findKeyAttribute(
-    path: NodePath<t.JSXOpeningElement>
-  ): t.JSXAttribute | null {
-    for (const attr of path.node.attributes) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        this.types.isJSXIdentifier(attr.name) &&
-        attr.name.name === "key"
-      ) {
-        return attr;
-      }
-    }
-    return null;
-  }
-
-  private extractKeyExpression(
-    attr: t.JSXAttribute
-  ): t.Expression | null {
-    if (!attr.value) return null;
-
-    if (this.types.isJSXExpressionContainer(attr.value)) {
-      const expr = attr.value.expression;
-      if (this.types.isExpression(expr)) return expr;
-    }
-
-    return null;
-  }
-}

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

@@ -1,225 +0,0 @@
-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;
-  }
-}