Merge pull request #41128 from appsmithorg/release

23/07 Daily Promotion

Author: btsgh

Dockerfile

@@ -11,9 +11,11 @@ ENV APPSMITH_SEGMENT_CE_KEY=${APPSMITH_SEGMENT_CE_KEY}
 
 COPY deploy/docker/fs /
 
-# Install git
 RUN apt-get update && \
-    apt-get install -y git && \
+    apt-get install -y software-properties-common && \
+    add-apt-repository -y ppa:git-core/ppa && \
+    apt-get update && \
+    apt-get install -y git tar zstd openssh-client && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
@@ -35,6 +37,9 @@ COPY ./app/client/build editor/
 # Add RTS - Application Layer
 COPY ./app/client/packages/rts/dist rts/
 
+# Create the git-storage directory with group writeable permissions so non-root users can write to it.
+RUN mkdir --mode 775 "/dev/shm/git-storage"
+
 ENV PATH /opt/bin:/opt/java/bin:/opt/node/bin:$PATH
 
 RUN <<END

app/client/packages/ast/src/index.ts

@@ -403,29 +403,45 @@ export interface IdentifierInfo {
   variables: string[];
   isError: boolean;
 }
+
+// Extracted function to sanitize, wrap, parse code, and call ancestorWalk, now with caching
+const sanitizedWrappedAncestorWalkCache = new Map<string, NodeList>();
+
+function getSanitizedWrappedAncestorWalk(
+  code: string,
+  evaluationVersion: number,
+): NodeList {
+  const cacheKey = `${evaluationVersion}::${code}`;
+
+  if (sanitizedWrappedAncestorWalkCache.has(cacheKey)) {
+    return sanitizedWrappedAncestorWalkCache.get(cacheKey)!;
+  }
+
+  const sanitizedScript = sanitizeScript(code, evaluationVersion);
+  // We sanitize and wrap the code because all code/script gets wrapped with a function during evaluation.
+  // Some syntax won't be valid unless they're at the RHS of a statement.
+  // Since we're assigning all code/script to RHS during evaluation, we do the same here.
+  // So that during ast parse, those errors are neglected.
+  // e.g. IIFE without braces:
+  //   function() { return 123; }() -> is invalid
+  //   let result = function() { return 123; }() -> is valid
+  const wrappedCode = wrapCode(sanitizedScript);
+  const ast = getAST(wrappedCode);
+  const result = ancestorWalk(ast);
+
+  sanitizedWrappedAncestorWalkCache.set(cacheKey, result);
+
+  return result;
+}
+
 export const extractIdentifierInfoFromCode = (
   code: string,
   evaluationVersion: number,
   invalidIdentifiers?: Record<string, unknown>,
 ): IdentifierInfo => {
-  let ast: Node = { end: 0, start: 0, type: "" };
-
   try {
-    const sanitizedScript = sanitizeScript(code, evaluationVersion);
-    /* wrapCode - Wrapping code in a function, since all code/script get wrapped with a function during evaluation.
-       Some syntax won't be valid unless they're at the RHS of a statement.
-       Since we're assigning all code/script to RHS during evaluation, we do the same here.
-       So that during ast parse, those errors are neglected.
-    */
-    /* e.g. IIFE without braces
-      function() { return 123; }() -> is invalid
-      let result = function() { return 123; }() -> is valid
-    */
-    const wrappedCode = wrapCode(sanitizedScript);
-
-    ast = getAST(wrappedCode);
     const { functionalParams, references, variableDeclarations }: NodeList =
-      ancestorWalk(ast);
+      getSanitizedWrappedAncestorWalk(code, evaluationVersion);
     const referencesArr = Array.from(references).filter((reference) => {
       // To remove references derived from declared variables and function params,
       // We extract the topLevelIdentifier Eg. Api1.name => Api1

app/client/src/ce/entities/FeatureFlag.ts

@@ -64,7 +64,6 @@ export const FEATURE_FLAG = {
     "release_jsobjects_onpageunloadactions_enabled",
   configure_block_event_tracking_for_anonymous_users:
     "configure_block_event_tracking_for_anonymous_users",
-  release_paid_features_tagging: "release_paid_features_tagging",
 } as const;
 
 export type FeatureFlag = keyof typeof FEATURE_FLAG;
@@ -117,7 +116,6 @@ export const DEFAULT_FEATURE_FLAG_VALUE: FeatureFlags = {
   license_ai_agent_instance_enabled: false,
   release_jsobjects_onpageunloadactions_enabled: false,
   configure_block_event_tracking_for_anonymous_users: false,
-  release_paid_features_tagging: false,
 };
 
 export const AB_TESTING_EVENT_KEYS = {

app/client/src/entities/DependencyMap/DependencyMapUtils.ts

@@ -96,19 +96,26 @@ export class DependencyMapUtils {
   ) {
     const dependencies = dependencyMap.rawDependencies;
 
+    // We don't want to process the same node multiple times
+    // STEP 1: Collect all unique nodes that need processing
+    const nodesToProcess = new Set<string>();
+
     for (const [node, deps] of dependencies.entries()) {
       if (affectedSet.has(node)) {
-        DependencyMapUtils.makeParentsDependOnChild(dependencyMap, node);
+        nodesToProcess.add(node); // Just add to set, don't call function yet
       }
 
-      deps.forEach((dep) => {
+      for (const dep of deps) {
         if (affectedSet.has(dep)) {
-          DependencyMapUtils.makeParentsDependOnChild(dependencyMap, dep);
+          nodesToProcess.add(dep); // Just add to set, don't call function yet
         }
-      });
+      }
     }
 
-    return dependencyMap;
+    // STEP 2: Process each unique node exactly once
+    for (const nodeToProcess of nodesToProcess) {
+      DependencyMapUtils.makeParentsDependOnChild(dependencyMap, nodeToProcess);
+    }
   }
 
   static makeParentsDependOnChild = (

app/client/src/entities/DependencyMap/index.ts

@@ -1,5 +1,4 @@
-import { difference } from "lodash";
-import { isChildPropertyPath } from "utils/DynamicBindingUtils";
+import { isChildPropertyPath, getDifferences } from "utils/DynamicBindingUtils";
 
 export type TDependencies = Map<string, Set<string>>;
 export default class DependencyMap {
@@ -107,9 +106,9 @@ export default class DependencyMap {
     const newNodeDependencies = validDependencies;
 
     // dependencies removed from path
-    const removedNodeDependencies = difference(
-      Array.from(previousNodeDependencies),
-      Array.from(newNodeDependencies),
+    const removedNodeDependencies = getDifferences(
+      previousNodeDependencies,
+      newNodeDependencies,
     );
 
     // Remove node from the inverseDependencies of removed deps
@@ -122,9 +121,9 @@ export default class DependencyMap {
     const newNodeInvalidDependencies = invalidDependencies;
 
     // invalid dependencies removed from path
-    const removedNodeInvalidDependencies = difference(
-      Array.from(previousNodeInvalidDependencies),
-      Array.from(newNodeInvalidDependencies),
+    const removedNodeInvalidDependencies = getDifferences(
+      previousNodeInvalidDependencies,
+      newNodeInvalidDependencies,
     );
 
     // Remove node from the inverseDependencies of removed invalidDeps

app/client/src/pages/AppIDE/layouts/components/Header/index.tsx

@@ -65,6 +65,7 @@ import { AppsmithLink } from "pages/Editor/AppsmithLink";
 import DeployButton from "./DeployButton";
 import { GitApplicationContextProvider } from "git-artifact-helpers/application/components";
 import ChevronMenu from "./ChevronMenu";
+import { ShowUpgradeMenuItem } from "ee/utils/licenseHelpers";
 
 const StyledDivider = styled(Divider)`
   height: 50%;
@@ -194,6 +195,7 @@ const Header = () => {
           )}
         </IDEHeader.Center>
         <IDEHeader.Right>
+          <ShowUpgradeMenuItem />
           <HelpBar />
           <StyledDivider orientation={"vertical"} />
           <ToggleModeButton />

app/client/src/pages/Editor/DataSidePane/DataSidePane.tsx

@@ -83,9 +83,6 @@ export const DataSidePane = (props: DataSidePaneProps) => {
   );
 
   const isFeatureEnabled = useFeatureFlag(FEATURE_FLAG.license_gac_enabled);
-  const isPaidFeaturesTaggingEnabled = useFeatureFlag(
-    FEATURE_FLAG.release_paid_features_tagging,
-  );
 
   const canCreateDatasource = getHasCreateDatasourcePermission(
     isFeatureEnabled,
@@ -113,8 +110,6 @@ export const DataSidePane = (props: DataSidePaneProps) => {
 
   const shouldShowPremiumTag = useCallback(
     (datasource: Datasource) => {
-      if (!isPaidFeaturesTaggingEnabled) return false;
-
       const plugin = plugins.find((p) => p.id === datasource.pluginId);
 
       if (!plugin) return false;
@@ -128,7 +123,7 @@ export const DataSidePane = (props: DataSidePaneProps) => {
 
       return false;
     },
-    [plugins, isIntegrationsEnabledForPaid, isPaidFeaturesTaggingEnabled],
+    [plugins, isIntegrationsEnabledForPaid],
   );
 
   return (

app/client/src/utils/DynamicBindingUtils.ts

@@ -640,3 +640,13 @@ export function getEntityName(
 
   if (isJSAction(entity)) return entityConfig.name;
 }
+
+export function getDifferences<T>(a: Set<T>, b: Set<T>): T[] {
+  const diff: T[] = [];
+
+  for (const val of a) {
+    if (!b.has(val)) diff.push(val);
+  }
+
+  return diff;
+}

app/client/src/workers/common/DataTreeEvaluator/index.ts

@@ -77,7 +77,6 @@ import {
   isObject,
   isUndefined,
   set,
-  union,
   unset,
 } from "lodash";
 
@@ -1008,30 +1007,30 @@ export default class DataTreeEvaluator {
     changes: Array<string>,
     inverseMap: Record<string, string[]>,
   ): Array<string> {
-    let finalSortOrder: Array<string> = [];
     let computeSortOrder = true;
     // Initialize parents with the current sent of property paths that need to be evaluated
     let parents = changes;
     let subSortOrderArray: Array<string>;
-    let visitedNodes: string[] = [];
+    const visitedNodesSet = new Set<string>();
+    // Remove duplicates from this list. Since we explicitly walk down the tree and implicitly (by fetching parents) walk
+    // up the tree, there are bound to be many duplicates.
+    const uniqueKeysInSortOrder = new Set<string>();
 
     while (computeSortOrder) {
       // Get all the nodes that would be impacted by the evaluation of the nodes in parents array in sorted order
       subSortOrderArray = this.getEvaluationSortOrder(parents, inverseMap);
-      visitedNodes = union(visitedNodes, parents);
-      // Add all the sorted nodes in the final list
-      finalSortOrder = union(finalSortOrder, subSortOrderArray);
+
+      // Add all parents and subSortOrderArray nodes to their respective sets
+      for (const node of parents) visitedNodesSet.add(node);
+
+      for (const node of subSortOrderArray) uniqueKeysInSortOrder.add(node);
 
       parents = getImmediateParentsOfPropertyPaths(subSortOrderArray);
       // If we find parents of the property paths in the sorted array, we should continue finding all the nodes dependent
       // on the parents
-      computeSortOrder = difference(parents, visitedNodes).length > 0;
+      computeSortOrder = parents.some((parent) => !visitedNodesSet.has(parent));
     }
 
-    // Remove duplicates from this list. Since we explicitly walk down the tree and implicitly (by fetching parents) walk
-    // up the tree, there are bound to be many duplicates.
-    const uniqueKeysInSortOrder = new Set(finalSortOrder);
-
     // if a property path evaluation gets triggered by diff top order changes
     // this could lead to incorrect sort order in spite of the bfs traversal
     const sortOrderPropertyPaths: string[] = [];

app/server/.gitignore

@@ -12,6 +12,6 @@ node_modules
 **/.project
 **/.factorypath
 container-volumes
-*.env
+*.env*
 dependency-reduced-pom.xml
 appsmith-server/failedServerTests.txt