@finos/legend-application-studio 28.21.46 → 28.21.48

package/src/components/editor/editor-group/dataProduct/DataProductEditor.tsx

@@ -117,7 +117,8 @@ import {
   type LakehouseAccessPoint,
   type Mapping,
   type PackageableElement,
-  type DataProduct,
+  type AccessPointGroup,
+  DataProduct,
   DataProductEmbeddedImageIcon,
   DataProductLibraryIcon,
   Email,
@@ -143,6 +144,8 @@ import {
 import {
   accessPoint_setClassification,
   accessPoint_setReproducible,
+  accessPointGroup_addTarget,
+  accessPointGroup_deleteTarget,
   accessPointGroup_setDescription,
   accessPointGroup_setName,
   dataProduct_setDescription,
@@ -199,11 +202,17 @@ import type { LegendStudioApplicationStore } from '../../../../stores/LegendStud
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import { RelationElementSampleValuesEditor } from '../data-editor/RelationElementSampleValuesEditor.js';
 import type {
+  AccessPointGroupMeta,
   AccessPointMeta,
   DataProductDocResponse,
   DSL_DataProduct_LegendStudioApplicationPlugin_Extension,
 } from '../../../../stores/extensions/DSL_DataProduct_LegendStudioApplicationPlugin_Extension.js';
-import { LegendStudioTelemetryHelper } from '../../../../__lib__/LegendStudioTelemetryHelper.js';
+import {
+  LEGENDAI_SUGGEST_MATCH_STRATEGY,
+  LEGENDAI_SUGGEST_STAGE,
+  LEGENDAI_SUGGEST_SURFACE,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
+import { useLegendAISuggestTelemetry } from '../LegendAISuggestTelemetryHooks.js';
 import { LEGEND_STUDIO_DOCUMENTATION_KEY } from '../../../../__lib__/LegendStudioDocumentation.js';
 
 export enum AP_GROUP_MODAL_ERRORS {
@@ -542,7 +551,13 @@ export const LakehouseDataProductAccessPointEditor = observer(
     };
 
     const updateAccessPointTargetEnvironment = action(
-      (targetEnvironment: LakehouseTargetEnv) => {
+      (targetEnvironment: LakehouseTargetEnv | undefined) => {
+        if (
+          targetEnvironment !== undefined &&
+          groupState.value.targets?.length
+        ) {
+          groupState.value.targets = undefined;
+        }
         accessPoint.targetEnvironment = targetEnvironment;
       },
     );
@@ -811,6 +826,15 @@ export const LakehouseDataProductAccessPointEditor = observer(
                     className="access-point-editor__dropdown"
                     content={
                       <MenuContent>
+                        <MenuContentItem
+                          className="btn__dropdown-combo__option"
+                          title="Clear"
+                          onClick={() =>
+                            updateAccessPointTargetEnvironment(undefined)
+                          }
+                        >
+                          {' '}
+                        </MenuContentItem>
                         {Object.values(LakehouseTargetEnv).map(
                           (environment) => (
                             <MenuContentItem
@@ -1164,6 +1188,43 @@ const AccessPointLoadingSentinel = (props: {
   ref?: React.Ref<HTMLDivElement>;
 }) => <div ref={props.ref} className="access-point-editor__sentinel" />;
 
+/**
+ * Finds the suggested metadata for an access point group: by group name
+ * first, falling back to the group's position in the product.
+ */
+const matchAccessPointGroupSuggestion = (
+  suggestion: DataProductDocResponse,
+  groupId: string,
+  groupIndex: number,
+): {
+  groupMeta: AccessPointGroupMeta | undefined;
+  accessPointMetas: AccessPointMeta[];
+} => {
+  const groupMeta =
+    suggestion.access_point_groups.find((g) => g.name === groupId) ??
+    suggestion.access_point_groups[groupIndex];
+  const accessPointMetas = suggestion.access_points.filter(
+    (ap) => ap.group === (groupMeta?.name ?? groupId),
+  );
+  return { groupMeta, accessPointMetas };
+};
+
+/**
+ * Flattens the access point group fields a LegendAI suggestion writes so the
+ * applied value can be compared with what is eventually pushed.
+ */
+const serializeAccessPointGroupAppliedFields = (
+  group: AccessPointGroup,
+  accessPointCount: number,
+): string =>
+  [
+    group.title ?? '',
+    group.description ?? '',
+    ...group.accessPoints
+      .slice(0, accessPointCount)
+      .flatMap((ap) => [ap.id, ap.title ?? '', ap.description ?? '']),
+  ].join('\n');
+
 const AccessPointGroupEditor = observer(
   (props: { groupState: AccessPointGroupState; isReadOnly: boolean }) => {
     const { groupState, isReadOnly } = props;
@@ -1275,6 +1336,31 @@ const AccessPointGroupEditor = observer(
       accessPointGroup_setTitle(groupState.value, val);
     };
 
+    const getTargetEnvironmentOptions = () => {
+      const existingTargets = groupState.value.targets ?? [];
+      return Object.values(LakehouseTargetEnv)
+        .filter((target) => !existingTargets.includes(target))
+        .map((target) => ({
+          label: target,
+          value: target,
+        }));
+    };
+
+    const handleAddTargetEnvironment = action(
+      (val: { label: string; value: LakehouseTargetEnv } | null): void => {
+        if (val) {
+          accessPointGroup_addTarget(groupState.value, val.value);
+          lakehouseAccessPointStates.forEach((accessPointState) => {
+            accessPointState.accessPoint.targetEnvironment = undefined;
+          });
+        }
+      },
+    );
+
+    const handleRemoveTargetEnvironment = (target: string) => {
+      accessPointGroup_deleteTarget(groupState.value, target);
+    };
+
     // AI suggestion for APG
     const legendAIUrl = editorStore.applicationStore.config.legendAIUrl;
     const aiDocSuggester = legendAIUrl
@@ -1287,38 +1373,71 @@ const AccessPointGroupEditor = observer(
           )
           .find(Boolean)
       : undefined;
+    const aiSuggestTelemetry = useLegendAISuggestTelemetry(
+      editorStore,
+      {
+        surface: LEGENDAI_SUGGEST_SURFACE.DATA_PRODUCT,
+        elementPath: productEditorState.product.path,
+        accessPointGroupId: groupState.value.id,
+      },
+      { legendAIUrl, available: Boolean(aiDocSuggester), isReadOnly },
+    );
     const suggestWithAI = async (): Promise<void> => {
       if (!aiDocSuggester || !legendAIUrl) {
         return;
       }
-      LegendStudioTelemetryHelper.logEvent_DataProductLegendAISuggestLaunched(
-        editorStore.applicationStore.telemetryService,
-        productEditorState.product.path,
-        editorStore.editorMode.getSourceInfo(),
-      );
+      const request = aiSuggestTelemetry.launch({
+        existingText: groupState.value.description,
+        accessPointCount: groupState.value.accessPoints.length,
+      });
       setIsSuggestingWithAI(true);
       setAISuggestion(undefined);
+      let stage = LEGENDAI_SUGGEST_STAGE.SERIALIZE;
       try {
         const definitions =
           await editorStore.graphManagerState.graphManager.graphToPureCode(
             editorStore.graphManagerState.graph,
           );
+        stage = LEGENDAI_SUGGEST_STAGE.REQUEST;
         const product = productEditorState.product;
         const suggestion = await aiDocSuggester(
           { definitions, data_product_name: product.path },
           legendAIUrl,
         );
+        const { groupMeta, accessPointMetas } = matchAccessPointGroupSuggestion(
+          suggestion,
+          groupState.value.id,
+          productEditorState.accessPointGroupStates.indexOf(groupState),
+        );
+        const shouldShow = aiSuggestTelemetry.succeed(request, {
+          // the response is structured, so measure the parts shown for this group
+          suggestionText: [
+            groupMeta?.title,
+            groupMeta?.description,
+            ...accessPointMetas.flatMap((ap) => [
+              ap.name,
+              ap.title,
+              ap.description,
+            ]),
+          ]
+            .filter(Boolean)
+            .join('\n'),
+          definitionsLength: definitions.length,
+          currentText: groupState.value.description,
+          confidence: groupMeta?.confidence,
+          accessPointSuggestionCount: accessPointMetas.length,
+        });
+        if (!shouldShow) {
+          editorStore.applicationStore.notificationService.notifyWarning(
+            `LegendAI did not return a suggestion for access point group '${groupState.value.id}'`,
+          );
+        }
         runInAction(() => {
-          setAISuggestion(suggestion);
+          setAISuggestion(shouldShow ? suggestion : undefined);
         });
       } catch (error) {
         assertErrorThrown(error);
-        LegendStudioTelemetryHelper.logEvent_DataProductLegendAISuggestFailure(
-          editorStore.applicationStore.telemetryService,
-          productEditorState.product.path,
-          error.message,
-          editorStore.editorMode.getSourceInfo(),
-        );
+        aiSuggestTelemetry.fail(request, error, stage);
         if (
           error instanceof NetworkClientError &&
           (error.response.status === HttpStatus.UNAUTHORIZED ||
@@ -1343,67 +1462,98 @@ const AccessPointGroupEditor = observer(
       if (!aiSuggestion) {
         return;
       }
-      LegendStudioTelemetryHelper.logEvent_DataProductLegendAISuggestApplied(
-        editorStore.applicationStore.telemetryService,
-        productEditorState.product.path,
-        editorStore.editorMode.getSourceInfo(),
-      );
+      const group = groupState.value;
+      const existingText = group.description;
       // Find matching group in the response
-      const gIdx =
-        productEditorState.accessPointGroupStates.indexOf(groupState);
-      const groupMeta =
-        aiSuggestion.access_point_groups.find(
-          (g) => g.name === groupState.value.id,
-        ) ?? aiSuggestion.access_point_groups[gIdx];
-      if (groupMeta) {
-        accessPointGroup_setTitle(groupState.value, groupMeta.title);
-        accessPointGroup_setDescription(
-          groupState.value,
-          groupMeta.description,
+      const { groupMeta, accessPointMetas: apMetas } =
+        matchAccessPointGroupSuggestion(
+          aiSuggestion,
+          group.id,
+          productEditorState.accessPointGroupStates.indexOf(groupState),
         );
+      const matchStrategy = !groupMeta
+        ? LEGENDAI_SUGGEST_MATCH_STRATEGY.NONE
+        : groupMeta.name === group.id
+          ? LEGENDAI_SUGGEST_MATCH_STRATEGY.NAME
+          : LEGENDAI_SUGGEST_MATCH_STRATEGY.INDEX;
+      if (groupMeta) {
+        accessPointGroup_setTitle(group, groupMeta.title);
+        accessPointGroup_setDescription(group, groupMeta.description);
       }
       // Apply access point metadata for this group
-      const apMetas = aiSuggestion.access_points.filter(
-        (ap) => ap.group === (groupMeta?.name ?? groupState.value.id),
+      const accessPointsUpdated = Math.min(
+        apMetas.length,
+        group.accessPoints.length,
       );
-      for (
-        let j = 0;
-        j < apMetas.length && j < groupState.value.accessPoints.length;
-        j++
-      ) {
+      let accessPointsRenamed = 0;
+      let namesSanitized = 0;
+      for (let j = 0; j < accessPointsUpdated; j++) {
         const apMeta = apMetas[j] as (typeof apMetas)[number];
-        const ap = groupState.value.accessPoints[
-          j
-        ] as (typeof groupState.value.accessPoints)[number];
+        const ap = group.accessPoints[j] as (typeof group.accessPoints)[number];
         // Convert suggested name to valid identifier (alphanumeric + underscore)
         const sanitizedName = apMeta.name.replace(/[^0-9a-zA-Z_]/g, '_');
+        if (sanitizedName !== apMeta.name) {
+          namesSanitized++;
+        }
         if (sanitizedName) {
+          if (ap.id !== sanitizedName) {
+            accessPointsRenamed++;
+          }
           ap.id = sanitizedName;
         }
         accessPoint_setTitle(ap, apMeta.title);
         accessPoint_setDescription(ap, apMeta.description);
       }
+      const productPath = productEditorState.product.path;
+      const groupId = group.id;
+      aiSuggestTelemetry.apply({
+        existingText,
+        appliedText:
+          groupMeta || accessPointsUpdated
+            ? serializeAccessPointGroupAppliedFields(group, accessPointsUpdated)
+            : '',
+        readCurrentText: (store) => {
+          const element =
+            store.graphManagerState.graph.getNullableElement(productPath);
+          const currentGroup =
+            element instanceof DataProduct
+              ? element.accessPointGroups.find((g) => g.id === groupId)
+              : undefined;
+          return currentGroup
+            ? {
+                found: true,
+                text: serializeAccessPointGroupAppliedFields(
+                  currentGroup,
+                  accessPointsUpdated,
+                ),
+              }
+            : { found: false };
+        },
+        dataProduct: {
+          matchStrategy,
+          accessPointsUpdated,
+          accessPointsRenamed,
+          namesSanitized,
+          accessPointCountMismatch:
+            apMetas.length !== group.accessPoints.length,
+        },
+      });
       setAISuggestion(undefined);
     };
     const discardAISuggestion = (): void => {
-      LegendStudioTelemetryHelper.logEvent_DataProductLegendAISuggestDiscarded(
-        editorStore.applicationStore.telemetryService,
-        productEditorState.product.path,
-        editorStore.editorMode.getSourceInfo(),
-      );
+      aiSuggestTelemetry.discard();
       setAISuggestion(undefined);
     };
 
     // Computed AI suggestion for current group
-    const groupIndex =
-      productEditorState.accessPointGroupStates.indexOf(groupState);
-    const aiGroupMeta =
-      aiSuggestion?.access_point_groups.find(
-        (g) => g.name === groupState.value.id,
-      ) ?? aiSuggestion?.access_point_groups[groupIndex];
-    const aiAccessPointMetas = aiSuggestion?.access_points.filter(
-      (ap) => ap.group === (aiGroupMeta?.name ?? groupState.value.id),
-    );
+    const { groupMeta: aiGroupMeta, accessPointMetas: aiAccessPointMetas } =
+      aiSuggestion
+        ? matchAccessPointGroupSuggestion(
+            aiSuggestion,
+            groupState.value.id,
+            productEditorState.accessPointGroupStates.indexOf(groupState),
+          )
+        : { groupMeta: undefined, accessPointMetas: undefined };
 
     const handleRemoveAccessPointGroup = (): void => {
       editorStore.applicationStore.alertService.setActionAlertInfo({
@@ -1630,6 +1780,47 @@ const AccessPointGroupEditor = observer(
             </div>
           )}
         </div>
+        <div className="data-product-editor__operational-input data-product-editor__apg-targets-input">
+          <div
+            className="panel__content__form__section__header__label"
+            style={{ justifyContent: 'space-between', width: '45rem' }}
+          >
+            Target Environments
+          </div>
+          <div className="panel__content__form__section__header__prompt">
+            Select where this Data Product will be deployed.
+          </div>
+          <div className="panel__content__form__section__list__id-list">
+            {groupState.value.targets?.map((target) => (
+              <div
+                className="panel__content__form__section__list__item"
+                key={target}
+              >
+                {target}
+                <button
+                  className="panel__content__form__section__list__item__remove-btn"
+                  disabled={isReadOnly}
+                  onClick={() => handleRemoveTargetEnvironment(target)}
+                  tabIndex={-1}
+                  title="Remove Target Environment"
+                >
+                  <TimesIcon />
+                </button>
+              </div>
+            ))}
+          </div>
+          <CustomSelectorInput
+            className="panel__content__form__section__dropdown"
+            options={getTargetEnvironmentOptions()}
+            onChange={handleAddTargetEnvironment}
+            placeholder={'Add Target Environment...'}
+            darkMode={
+              !productEditorState.editorStore.applicationStore.layoutService
+                .TEMPORARY__isLightColorThemeEnabled
+            }
+            disabled={isReadOnly}
+          />
+        </div>
         {editorStore.applicationStore.config.options.dataProductConfig && (
           <AccessPointGroupPublicToggle groupState={groupState} />
         )}
@@ -2375,28 +2566,26 @@ const HomeTab = observer(
             <div className="panel__content__form__section__header__prompt">
               Select if this Data Product is Internal or External
             </div>
-            <div className="panel__content__form__section__list__new-item__input">
-              <CustomSelectorInput
-                options={DATA_PRODUCT_TYPE_OPTIONS}
-                onChange={handleDataProductTypeChange}
-                value={
-                  product.type instanceof InternalDataProductType
+            <CustomSelectorInput
+              className="panel__content__form__section__dropdown"
+              options={DATA_PRODUCT_TYPE_OPTIONS}
+              onChange={handleDataProductTypeChange}
+              value={
+                product.type instanceof InternalDataProductType
+                  ? DATA_PRODUCT_TYPE_OPTIONS.find(
+                      (option) => option.value === DATA_PRODUCT_TYPE.INTERNAL,
+                    )
+                  : product.type instanceof ExternalDataProductType
                     ? DATA_PRODUCT_TYPE_OPTIONS.find(
-                        (option) => option.value === DATA_PRODUCT_TYPE.INTERNAL,
+                        (option) => option.value === DATA_PRODUCT_TYPE.EXTERNAL,
                       )
-                    : product.type instanceof ExternalDataProductType
-                      ? DATA_PRODUCT_TYPE_OPTIONS.find(
-                          (option) =>
-                            option.value === DATA_PRODUCT_TYPE.EXTERNAL,
-                        )
-                      : null
-                }
-                darkMode={
-                  !dataProductEditorState.editorStore.applicationStore
-                    .layoutService.TEMPORARY__isLightColorThemeEnabled
-                }
-              />
-            </div>
+                    : null
+              }
+              darkMode={
+                !dataProductEditorState.editorStore.applicationStore
+                  .layoutService.TEMPORARY__isLightColorThemeEnabled
+              }
+            />
             {product.type instanceof ExternalDataProductType && (
               <div className="data-product-editor__external-link">
                 <div className="panel__content__form__section__header__prompt">
@@ -2994,15 +3183,14 @@ const OperationalTab = observer(
               </div>
             ))}
           </div>
-          <div className="panel__content__form__section__list__new-item__input">
-            <CustomSelectorInput<EnumOption<Region>>
-              options={getCoverageRegionOptions()}
-              onChange={handleAddRegion}
-              placeholder={CHOOSE_REGION}
-              darkMode={true}
-              disabled={isReadOnly}
-            />
-          </div>
+          <CustomSelectorInput<EnumOption<Region>>
+            className="panel__content__form__section__dropdown"
+            options={getCoverageRegionOptions()}
+            onChange={handleAddRegion}
+            placeholder={CHOOSE_REGION}
+            darkMode={true}
+            disabled={isReadOnly}
+          />
         </div>
         <div className="data-product-editor__operational-input">
           <div
@@ -3014,28 +3202,27 @@ const OperationalTab = observer(
           <div className="panel__content__form__section__header__prompt">
             Select the update frequency of this Data Product.
           </div>
-          <div className="panel__content__form__section__list__new-item__input">
-            <CustomSelectorInput<EnumOption<DeliveryFrequency>>
-              options={(
-                Object.values(DeliveryFrequency) as DeliveryFrequency[]
-              ).map((frequency) => ({
-                label: frequency,
-                value: frequency,
-              }))}
-              onChange={handleUpdateFrequencyChange}
-              value={
-                product.operationalMetadata?.updateFrequency
-                  ? {
-                      label: product.operationalMetadata.updateFrequency,
-                      value: product.operationalMetadata.updateFrequency,
-                    }
-                  : null
-              }
-              placeholder="Select update frequency..."
-              darkMode={true}
-              disabled={isReadOnly}
-            />
-          </div>
+          <CustomSelectorInput<EnumOption<DeliveryFrequency>>
+            className="panel__content__form__section__dropdown"
+            options={(
+              Object.values(DeliveryFrequency) as DeliveryFrequency[]
+            ).map((frequency) => ({
+              label: frequency,
+              value: frequency,
+            }))}
+            onChange={handleUpdateFrequencyChange}
+            value={
+              product.operationalMetadata?.updateFrequency
+                ? {
+                    label: product.operationalMetadata.updateFrequency,
+                    value: product.operationalMetadata.updateFrequency,
+                  }
+                : null
+            }
+            placeholder="Select update frequency..."
+            darkMode={true}
+            disabled={isReadOnly}
+          />
         </div>
       </div>
     );

package/src/components/editor/editor-group/dataProduct/DataProductQueryBuilderHelper.ts

@@ -17,7 +17,6 @@
 import {
   type DataProduct,
   type DataProductAccessor,
-  type NativeModelExecutionContext,
   LakehouseAccessPoint,
   ModelAccessPointGroup,
 } from '@finos/legend-graph';
@@ -39,9 +38,6 @@ import {
 
 const isQueryableDataProduct = (dataProduct: DataProduct): boolean => {
   return (
-    Boolean(
-      dataProduct.nativeModelAccess?.nativeModelExecutionContexts.length,
-    ) ||
     dataProduct.accessPointGroups.filter(filterByType(ModelAccessPointGroup))
       .length > 0 ||
     dataProduct.accessPointGroups
@@ -53,13 +49,7 @@ const isQueryableDataProduct = (dataProduct: DataProduct): boolean => {
 
 const resolveDefaultExecState = (
   dataProduct: DataProduct,
-):
-  | ModelAccessPointGroup
-  | LakehouseAccessPoint
-  | NativeModelExecutionContext
-  | undefined => {
-  const nativeAccessPoints =
-    dataProduct.nativeModelAccess?.defaultExecutionContext;
+): ModelAccessPointGroup | LakehouseAccessPoint | undefined => {
   const modeled = dataProduct.accessPointGroups.filter(
     filterByType(ModelAccessPointGroup),
   )[0];
@@ -67,7 +57,7 @@ const resolveDefaultExecState = (
     .map((group) => group.accessPoints)
     .flat()
     .filter(filterByType(LakehouseAccessPoint))[0];
-  return modeled ?? lakehouseAccessPoints ?? nativeAccessPoints;
+  return modeled ?? lakehouseAccessPoints;
 };
 
 export const queryDataProduct = async (
@@ -77,7 +67,7 @@ export const queryDataProduct = async (
   try {
     assertTrue(
       isQueryableDataProduct(dataProduct),
-      'Data Product is not queryable. Data Product must have either a lakehouse, model or native access point',
+      'Data Product is not queryable. Data Product must have either a lakehouse or model access point',
     );
     const embeddedQueryBuilderState = editorStore.embeddedQueryBuilderState;
     const defaultExecutionContext = guaranteeNonNullable(