@base44-preview/vite-plugin 0.2.25-pr.36.792e85b → 0.2.26-pr.43.056eecd

package/src/processors/shared-utils.ts

@@ -1,6 +1,7 @@
 import type { NodePath } from "@babel/traverse";
 import type * as t from "@babel/types";
 import { JSXUtils } from "../jsx-utils.js";
+import { ALLOWED_CUSTOM_COMPONENTS, EXCLUDED_FIELDS } from "../consts.js";
 
 export class JSXAttributeUtils {
   constructor(private types: typeof t) {}
@@ -16,6 +17,32 @@ export class JSXAttributeUtils {
     );
   }
 
+  getAttributeValue(
+    path: NodePath<t.JSXOpeningElement>,
+    attributeName: string
+  ): t.JSXAttribute["value"] | null {
+    for (const attr of path.node.attributes) {
+      if (
+        this.types.isJSXAttribute(attr) &&
+        JSXUtils.getAttributeName(attr) === attributeName
+      ) {
+        return attr.value;
+      }
+    }
+    return null;
+  }
+
+  getAttributeStringValue(
+    path: NodePath<t.JSXOpeningElement>,
+    attributeName: string
+  ): string | null {
+    const value = this.getAttributeValue(path, attributeName);
+    if (value && this.types.isStringLiteral(value)) {
+      return value.value;
+    }
+    return null;
+  }
+
   addStringAttribute(
     path: NodePath<t.JSXOpeningElement>,
     attributeName: string,
@@ -45,6 +72,475 @@ export class JSXAttributeUtils {
       );
     }
   }
+
+  findAncestorWithAttribute(
+    path: NodePath,
+    attributeName: string
+  ): NodePath<t.JSXOpeningElement> | null {
+    let current: NodePath | null = path.parentPath;
+    while (current) {
+      if (current.isJSXElement()) {
+        const opening = current.get("openingElement");
+        if (this.hasAttribute(opening, attributeName)) {
+          return opening;
+        }
+      }
+      current = current.parentPath;
+    }
+    return null;
+  }
+}
+
+export class PathNavigationUtils {
+  constructor(private types: typeof t) {}
+
+  findParentJSXElement(
+    path: NodePath
+  ): NodePath<t.JSXElement> | null {
+    let current: NodePath | null = path.parentPath;
+    while (current) {
+      if (current.isJSXElement()) return current;
+      current = current.parentPath;
+    }
+    return null;
+  }
+
+  findEnclosingFunction(
+    path: NodePath
+  ): NodePath<t.Function> | null {
+    let current: NodePath | null = path.parentPath;
+    while (current) {
+      if (current.isFunction()) return current as NodePath<t.Function>;
+      current = current.parentPath;
+    }
+    return null;
+  }
+
+  findReturnStatement(
+    path: NodePath
+  ): NodePath<t.ReturnStatement> | null {
+    let current: NodePath | null = path.parentPath;
+    while (current) {
+      if (current.isReturnStatement()) return current;
+      current = current.parentPath;
+    }
+    return null;
+  }
+
+  isRootReturnElement(
+    path: NodePath<t.JSXOpeningElement>
+  ): boolean {
+    const jsxElement = path.parentPath;
+    if (!jsxElement?.isJSXElement()) return false;
+
+    const parent = jsxElement.parentPath;
+    if (!parent) return false;
+
+    if (parent.isReturnStatement()) return true;
+
+    if (parent.isArrowFunctionExpression()) return true;
+
+    if (parent.isParenthesizedExpression()) {
+      const grandparent = parent.parentPath;
+      if (grandparent?.isReturnStatement()) return true;
+      if (grandparent?.isArrowFunctionExpression()) return true;
+    }
+
+    return false;
+  }
+
+  findDOMElementTarget(
+    path: NodePath<t.JSXOpeningElement>
+  ): NodePath<t.JSXOpeningElement> | null {
+    if (this.isDOMOrAllowedElement(path)) return path;
+
+    let current: NodePath | null = path.parentPath;
+    while (current) {
+      if (current.isJSXElement()) {
+        const opening = current.get("openingElement");
+        if (this.isDOMOrAllowedElement(opening)) return opening;
+      }
+      current = current.parentPath;
+    }
+    return null;
+  }
+
+  private isDOMOrAllowedElement(
+    path: NodePath<t.JSXOpeningElement>
+  ): boolean {
+    const name = JSXUtils.getElementName(path.node);
+    if (!name) return false;
+
+    if (name.charAt(0) === name.charAt(0).toLowerCase()) return true;
+
+    return ALLOWED_CUSTOM_COMPONENTS.includes(name);
+  }
+}
+
+export class ExpressionAnalysisUtils {
+  constructor(private types: typeof t) {}
+
+  isIdAccess(node: t.Expression): boolean {
+    return (
+      this.types.isMemberExpression(node) &&
+      ((this.types.isIdentifier(node.property) &&
+        node.property.name === "_id") ||
+        (this.types.isStringLiteral(node.property) &&
+          node.property.value === "_id"))
+    );
+  }
+
+  isItemsAccess(node: t.Expression): boolean {
+    return (
+      this.types.isMemberExpression(node) &&
+      this.types.isIdentifier(node.property) &&
+      node.property.name === "items"
+    );
+  }
+
+  isLengthAccess(node: t.Expression): boolean {
+    return (
+      this.types.isMemberExpression(node) &&
+      this.types.isIdentifier(node.property) &&
+      node.property.name === "length"
+    );
+  }
+
+  extractRootIdentifier(node: t.Expression): t.Identifier | null {
+    if (this.types.isIdentifier(node)) return node;
+    if (this.types.isMemberExpression(node)) {
+      return this.extractRootIdentifier(node.object as t.Expression);
+    }
+    if (this.types.isOptionalMemberExpression(node)) {
+      return this.extractRootIdentifier(node.object as t.Expression);
+    }
+    if (this.types.isCallExpression(node) && this.types.isMemberExpression(node.callee)) {
+      return this.extractRootIdentifier(node.callee.object as t.Expression);
+    }
+    return null;
+  }
+
+  unwrapLogicalExpression(node: t.Expression): t.Expression {
+    if (this.types.isLogicalExpression(node)) {
+      if (node.operator === "&&") return node.right as t.Expression;
+      if (node.operator === "||" || node.operator === "??") {
+        return node.left as t.Expression;
+      }
+    }
+    return node;
+  }
+
+  collectMemberExpressionPath(node: t.Expression): string[] {
+    const parts: string[] = [];
+    let current: t.Expression = node;
+
+    while (
+      this.types.isMemberExpression(current) ||
+      this.types.isOptionalMemberExpression(current)
+    ) {
+      const prop = (current as t.MemberExpression).property;
+      if (this.types.isIdentifier(prop)) {
+        parts.unshift(prop.name);
+      } else if (this.types.isStringLiteral(prop)) {
+        parts.unshift(prop.value);
+      }
+      current = (current as t.MemberExpression).object as t.Expression;
+    }
+
+    if (this.types.isIdentifier(current)) {
+      parts.unshift(current.name);
+    }
+
+    return parts;
+  }
+
+  createOptionalChainExpression(
+    node: t.MemberExpression
+  ): t.OptionalMemberExpression {
+    const object = this.types.isOptionalMemberExpression(node.object)
+      ? node.object
+      : this.types.isMemberExpression(node.object)
+        ? this.createOptionalChainExpression(node.object)
+        : node.object;
+
+    const property = node.property as t.Expression;
+
+    return this.types.optionalMemberExpression(
+      object,
+      property,
+      node.computed,
+      true
+    );
+  }
+
+  getFieldPathFromExpression(
+    node: t.Expression,
+    rootName: string
+  ): string | null {
+    const parts = this.collectMemberExpressionPath(node);
+    if (parts.length < 2) return null;
+    if (parts[0] !== rootName) return null;
+
+    const fieldParts = parts.slice(1);
+    const fieldPath = fieldParts.join(".");
+
+    if (EXCLUDED_FIELDS.includes(fieldPath)) return null;
+    return fieldPath;
+  }
+}
+
+export class BindingUtils {
+  constructor(private types: typeof t) {}
+
+  isFunctionParameter(
+    identifierName: string,
+    path: NodePath
+  ): boolean {
+    const fn = path.getFunctionParent();
+    if (!fn) return false;
+
+    const params = fn.get("params");
+    for (const param of (Array.isArray(params) ? params : [params])) {
+      if (param.isIdentifier() && param.node.name === identifierName) {
+        return true;
+      }
+      if (param.isObjectPattern()) {
+        for (const prop of param.get("properties")) {
+          if (
+            prop.isObjectProperty() &&
+            this.types.isIdentifier(prop.node.value) &&
+            prop.node.value.name === identifierName
+          ) {
+            return true;
+          }
+        }
+      }
+      if (param.isArrayPattern()) {
+        for (const el of param.get("elements")) {
+          if (el.isIdentifier() && el.node.name === identifierName) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  isUseStateCall(
+    init: NodePath<t.Node>
+  ): { stateIndex: number; setterName: string | null } | null {
+    if (!init.isCallExpression()) return null;
+
+    const callee = init.get("callee");
+    if (!callee.isIdentifier() || callee.node.name !== "useState") return null;
+
+    const declarator = init.parentPath;
+    if (!declarator?.isVariableDeclarator()) return null;
+
+    const id = declarator.get("id");
+    if (!id.isArrayPattern()) return null;
+
+    const elements = id.get("elements");
+    const setterEl = elements[1];
+    const setterName =
+      setterEl && setterEl.isIdentifier() ? setterEl.node.name : null;
+
+    return { stateIndex: 0, setterName };
+  }
+
+  isPromiseAllCall(
+    init: NodePath<t.Node>
+  ): boolean {
+    if (!init.isAwaitExpression()) {
+      if (init.isCallExpression()) {
+        const callee = init.get("callee");
+        return this.isPromiseAllCallee(callee);
+      }
+      return false;
+    }
+
+    const argument = init.get("argument");
+    if (!argument.isCallExpression()) return false;
+
+    const callee = argument.get("callee");
+    return this.isPromiseAllCallee(callee);
+  }
+
+  private isPromiseAllCallee(callee: NodePath): boolean {
+    if (!callee.isMemberExpression()) return false;
+    const obj = callee.get("object") as NodePath;
+    const prop = callee.get("property") as NodePath;
+    return (
+      obj.isIdentifier() &&
+      obj.node.name === "Promise" &&
+      prop.isIdentifier() &&
+      prop.node.name === "all"
+    );
+  }
+
+  extractDestructuredProperties(
+    pattern: t.ObjectPattern
+  ): string[] {
+    const properties: string[] = [];
+    for (const prop of pattern.properties) {
+      if (this.types.isObjectProperty(prop)) {
+        if (this.types.isIdentifier(prop.key)) {
+          properties.push(prop.key.name);
+        } else if (this.types.isStringLiteral(prop.key)) {
+          properties.push(prop.key.value);
+        }
+      }
+    }
+    return properties;
+  }
+
+  findSetterCallInScope(
+    setterName: string,
+    scope: NodePath
+  ): NodePath<t.CallExpression> | null {
+    let result: NodePath<t.CallExpression> | null = null;
+
+    scope.traverse({
+      CallExpression(callPath) {
+        if (result) return;
+        const callee = callPath.get("callee");
+        if (callee.isIdentifier() && callee.node.name === setterName) {
+          result = callPath;
+        }
+      },
+    });
+
+    return result;
+  }
+}
+
+export class CallExpressionUtils {
+  constructor(private types: typeof t) {}
+
+  isGetAllCall(
+    node: t.CallExpression
+  ): { collectionName: string; references: string[] } | null {
+    const callee = node.callee;
+    if (!this.types.isMemberExpression(callee)) return null;
+
+    const obj = callee.object;
+    const prop = callee.property;
+
+    if (
+      !this.types.isIdentifier(obj) ||
+      obj.name !== "BaseCrudService" ||
+      !this.types.isIdentifier(prop) ||
+      prop.name !== "getAll"
+    ) {
+      return null;
+    }
+
+    const args = node.arguments;
+    if (args.length < 1) return null;
+
+    const firstArg = args[0];
+    if (!this.types.isStringLiteral(firstArg)) return null;
+
+    const collectionName = firstArg.value;
+    const references = this.extractReferencesFromArg(args[1]);
+
+    return { collectionName, references };
+  }
+
+  isGetByIdCall(
+    node: t.CallExpression
+  ): {
+    collectionName: string;
+    multiRefFields: string[];
+  } | null {
+    const callee = node.callee;
+    if (!this.types.isMemberExpression(callee)) return null;
+
+    const obj = callee.object;
+    const prop = callee.property;
+
+    if (
+      !this.types.isIdentifier(obj) ||
+      obj.name !== "BaseCrudService" ||
+      !this.types.isIdentifier(prop) ||
+      prop.name !== "getById"
+    ) {
+      return null;
+    }
+
+    const args = node.arguments;
+    if (args.length < 1) return null;
+
+    const firstArg = args[0];
+    if (!this.types.isStringLiteral(firstArg)) return null;
+
+    const collectionName = firstArg.value;
+    const multiRefFields = this.extractMultiRefFromOptions(args[2]);
+
+    return { collectionName, multiRefFields };
+  }
+
+  private extractReferencesFromArg(
+    arg: t.Expression | t.SpreadElement | t.ArgumentPlaceholder | undefined
+  ): string[] {
+    if (!arg || !this.types.isArrayExpression(arg)) return [];
+
+    return arg.elements
+      .filter((el): el is t.StringLiteral => this.types.isStringLiteral(el))
+      .map((el) => el.value);
+  }
+
+  private extractMultiRefFromOptions(
+    arg: t.Expression | t.SpreadElement | t.ArgumentPlaceholder | undefined
+  ): string[] {
+    if (!arg || !this.types.isObjectExpression(arg)) return [];
+
+    for (const prop of arg.properties) {
+      if (
+        this.types.isObjectProperty(prop) &&
+        this.types.isIdentifier(prop.key) &&
+        prop.key.name === "multiRef" &&
+        this.types.isArrayExpression(prop.value)
+      ) {
+        return prop.value.elements
+          .filter((el): el is t.StringLiteral =>
+            this.types.isStringLiteral(el)
+          )
+          .map((el) => el.value);
+      }
+    }
+    return [];
+  }
+
+  isArrayMethod(
+    node: t.CallExpression,
+    methodName: string
+  ): boolean {
+    const callee = node.callee;
+    return (
+      this.types.isMemberExpression(callee) &&
+      this.types.isIdentifier(callee.property) &&
+      callee.property.name === methodName
+    );
+  }
+
+  isChainedArrayMethod(node: t.CallExpression): boolean {
+    const chainMethods = ["filter", "sort", "slice", "concat", "reverse", "flat"];
+    return chainMethods.some((m) => this.isArrayMethod(node, m));
+  }
+
+  getCallbackArgument(
+    callExpr: t.CallExpression
+  ): t.ArrowFunctionExpression | t.FunctionExpression | null {
+    const firstArg = callExpr.arguments[0];
+    if (
+      this.types.isArrowFunctionExpression(firstArg) ||
+      this.types.isFunctionExpression(firstArg)
+    ) {
+      return firstArg;
+    }
+    return null;
+  }
 }
 
 export class StaticValueUtils {
@@ -113,4 +609,103 @@ export class StaticValueUtils {
       return this.isStaticValue(element as unknown as NodePath<t.Node>, visited);
     });
   }
+
+  isDerivedFromStaticData(
+    identifierName: string,
+    path: NodePath
+  ): boolean {
+    const binding = path.scope.getBinding(identifierName);
+    if (!binding) return false;
+
+    if (binding.path.isVariableDeclarator()) {
+      const init = binding.path.get("init");
+      if (init.isArrayExpression() || init.isObjectExpression()) {
+        return this.isStaticValue(init as NodePath<t.Node>);
+      }
+    }
+
+    const fnParent = path.getFunctionParent();
+    if (!fnParent) return false;
+
+    const params = fnParent.get("params");
+    for (const param of (Array.isArray(params) ? params : [params])) {
+      if (param.isIdentifier() && param.node.name === identifierName) {
+        const mapCall = fnParent.parentPath;
+        if (mapCall?.isCallExpression()) {
+          const callee = mapCall.get("callee");
+          if (
+            callee.isMemberExpression() &&
+            (callee.get("property") as NodePath).isIdentifier()
+          ) {
+            const propName = ((callee.get("property") as NodePath).node as t.Identifier).name;
+            if (propName === "map" || propName === "flatMap") {
+              const arrayObj = callee.get("object") as NodePath<t.Expression>;
+              if (arrayObj.isIdentifier()) {
+                return this.isDerivedFromStaticData(arrayObj.node.name, arrayObj);
+              }
+              if (arrayObj.isArrayExpression()) {
+                return this.isStaticArrayExpression(arrayObj);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+export class TypeCheckUtils {
+  constructor(private types: typeof t) {}
+
+  isArrayIsArrayCheck(node: t.Expression): boolean {
+    if (!this.types.isCallExpression(node)) return false;
+
+    const callee = node.callee;
+    return (
+      this.types.isMemberExpression(callee) &&
+      this.types.isIdentifier(callee.object) &&
+      callee.object.name === "Array" &&
+      this.types.isIdentifier(callee.property) &&
+      callee.property.name === "isArray"
+    );
+  }
+
+  isTypeofObjectCheck(node: t.Expression): boolean {
+    if (!this.types.isBinaryExpression(node)) return false;
+    if (node.operator !== "===" && node.operator !== "==") return false;
+
+    const isTypeof = (side: t.Expression) =>
+      this.types.isUnaryExpression(side) && side.operator === "typeof";
+    const isObjectString = (side: t.Expression) =>
+      this.types.isStringLiteral(side) && side.value === "object";
+
+    return (
+      (isTypeof(node.left as t.Expression) &&
+        isObjectString(node.right as t.Expression)) ||
+      (isObjectString(node.left as t.Expression) &&
+        isTypeof(node.right as t.Expression))
+    );
+  }
+
+  isReferenceTypeCheck(node: t.Expression): boolean {
+    return this.isArrayIsArrayCheck(node) || this.isTypeofObjectCheck(node);
+  }
+
+  isLengthCheck(node: t.Expression): boolean {
+    if (this.types.isMemberExpression(node)) {
+      return (
+        this.types.isIdentifier(node.property) &&
+        node.property.name === "length"
+      );
+    }
+    if (this.types.isOptionalMemberExpression(node)) {
+      return (
+        this.types.isIdentifier(node.property) &&
+        node.property.name === "length"
+      );
+    }
+    return false;
+  }
 }

package/src/processors/static-array-processor.ts

@@ -1,10 +1,13 @@
 import type { NodePath } from "@babel/traverse";
 import type * as t from "@babel/types";
+import {
+  DATA_ARR_INDEX,
+  DATA_ARR_VARIABLE_NAME,
+  DATA_ARR_FIELD,
+} from "../consts.js";
 import { JSXAttributeUtils, StaticValueUtils } from "./shared-utils.js";
 
-export const DATA_ARR_INDEX = "data-arr-index";
-export const DATA_ARR_VARIABLE_NAME = "data-arr-variable-name";
-export const DATA_ARR_FIELD = "data-arr-field";
+export { DATA_ARR_INDEX, DATA_ARR_VARIABLE_NAME, DATA_ARR_FIELD };
 const GENERATED_INDEX_PARAM = "__arrIdx__";
 
 interface ArrayMapInfo {

package/src/types.ts

@@ -0,0 +1,4 @@
+export interface CollectionInfo {
+  id: string;
+  references: string[];
+}