@finos/legend-application-studio 28.19.50 → 28.19.52

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

@@ -94,27 +94,28 @@ import { CODE_EDITOR_LANGUAGE } from '@finos/legend-code-editor';
 import { CodeEditor } from '@finos/legend-lego/code-editor';
 import {
   type DataProduct,
+  type DataProductElement,
+  type DataProductElementScope,
+  type DataProductRuntimeInfo,
+  type Expertise,
   type GraphManagerState,
   type LakehouseAccessPoint,
-  type V1_DataProductArtifactAccessPointGroup,
-  type V1_DataProductArtifactAccessPointImplementation,
-  type V1_DataProductArtifactGeneration,
   type Mapping,
-  type PackageableRuntime,
-  type DataProductRuntimeInfo,
   type PackageableElement,
-  type DataProductElementScope,
-  type DataProductElement,
+  type PackageableRuntime,
+  type V1_AccessPointGroupInfo,
+  type V1_AccessPointImplementation,
+  type V1_DataProductArtifact,
   DataProductEmbeddedImageIcon,
   DataProductLibraryIcon,
   Email,
   LakehouseTargetEnv,
   StereotypeExplicitReference,
+  V1_DataProduct,
   V1_DataProductIconLibraryId,
-  validate_PureExecutionMapping,
   V1_PureGraphManager,
   V1_RemoteEngine,
-  V1_DataProduct,
+  validate_PureExecutionMapping,
 } from '@finos/legend-graph';
 import {
   accessPoint_setClassification,
@@ -134,6 +135,10 @@ import {
   runtimeInfo_setDescription,
   supportInfo_setSupportUrl,
   supportInfo_setWebsite,
+  expertise_setDescription,
+  expertise_addId,
+  expertise_deleteId,
+  dataProduct_deleteExpertise,
 } from '../../../../stores/graph-modifier/DSL_DataProduct_GraphModifierHelper.js';
 import { LEGEND_STUDIO_TEST_ID } from '../../../../__lib__/LegendStudioTesting.js';
 import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../../../__lib__/LegendStudioApplicationNavigationContext.js';
@@ -156,6 +161,7 @@ import {
   ProductViewer,
 } from '@finos/legend-extension-dsl-data-product';
 import type { LegendStudioApplicationStore } from '../../../../stores/LegendStudioBaseStore.js';
+import type { DepotServerClient } from '@finos/legend-server-depot';
 
 export enum AP_GROUP_MODAL_ERRORS {
   GROUP_NAME_EMPTY = 'Group Name is empty',
@@ -489,16 +495,15 @@ export const LakehouseDataProductAccessPointEditor = observer(
         if (dataProductContent) {
           const contentJson = JSON.parse(
             dataProductContent,
-          ) as V1_DataProductArtifactGeneration;
+          ) as V1_DataProductArtifact;
           const apPlanGeneration = contentJson.accessPointGroups
             .find(
-              (group: V1_DataProductArtifactAccessPointGroup) =>
+              (group: V1_AccessPointGroupInfo) =>
                 group.id === groupState.value.id,
             )
             ?.accessPointImplementations.find(
-              (
-                apImplementation: V1_DataProductArtifactAccessPointImplementation,
-              ) => apImplementation.id === accessPoint.id,
+              (apImplementation: V1_AccessPointImplementation) =>
+                apImplementation.id === accessPoint.id,
             );
 
           setDebugOutput(JSON.stringify(apPlanGeneration, null, 2));
@@ -1933,6 +1938,145 @@ const HomeTab = observer(
   },
 );
 
+const ExpertiseEditor = observer(
+  (props: { dataProductEditorState: DataProductEditorState }) => {
+    const { dataProductEditorState } = props;
+    const product = dataProductEditorState.product;
+
+    const NewExpertIdComponent = observer(
+      (newElementProps: { expertise: Expertise }) => {
+        const { expertise } = newElementProps;
+        const [title, setTitle] = useState('');
+
+        return (
+          <div className="data-product-editor__support-info__expertise-id-container">
+            <div className="panel__content__form__section__list__new-item__input">
+              <input
+                className="input input-group__input panel__content__form__section__input input--dark"
+                type="title"
+                placeholder="Enter User ID"
+                value={title}
+                onChange={(event) => {
+                  setTitle(event.target.value);
+                }}
+              />
+            </div>
+            <button
+              className="panel__content__form__section__list__new-item__add-btn btn btn--dark"
+              onClick={() => {
+                expertise_addId(expertise, title);
+                setTitle('');
+              }}
+            >
+              Save
+            </button>
+          </div>
+        );
+      },
+    );
+
+    const addNewExpertise = () => {
+      dataProductEditorState.createExpertise();
+    };
+
+    const updateExpertiseDescription = (
+      expertise: Expertise,
+      val: string | undefined,
+    ): void => {
+      if (val) {
+        expertise_setDescription(expertise, val);
+      }
+    };
+
+    const handleRemoveId = (expertise: Expertise, id: string) => {
+      expertise_deleteId(expertise, id);
+    };
+
+    const handleRemoveExpertise = (expertise: Expertise) => {
+      dataProduct_deleteExpertise(product, expertise);
+    };
+
+    return (
+      <>
+        <PanelHeader className="panel__header--access-point">
+          <div className="panel__content__form__section__header__label">
+            Expertise
+          </div>
+          <PanelHeaderActions>
+            <PanelHeaderActionItem
+              className="panel__header__action"
+              onClick={addNewExpertise}
+              title="Add new expertise"
+            >
+              <PlusIcon />
+            </PanelHeaderActionItem>
+          </PanelHeaderActions>
+        </PanelHeader>
+        {dataProductEditorState.product.expertise?.map((expertise) => (
+          <>
+            <div className="data-product-editor__expertise">
+              <div className="panel__content__form__section">
+                <div className="panel__content__form__section__header__prompt">
+                  Description
+                </div>
+                <textarea
+                  className="panel__content__form__section__textarea"
+                  spellCheck={false}
+                  disabled={dataProductEditorState.isReadOnly}
+                  value={expertise.description ?? ''}
+                  onChange={(event) =>
+                    updateExpertiseDescription(expertise, event.target.value)
+                  }
+                  style={{
+                    height: '100%',
+                  }}
+                />
+              </div>
+              <div className="panel__content__form__section">
+                <div className="panel__content__form__section__header__prompt">
+                  User IDs
+                </div>
+                <div className="panel__content__form__section__list__id-list">
+                  {expertise.expertIds?.map((id) => (
+                    <div
+                      className="panel__content__form__section__list__item"
+                      key={id}
+                    >
+                      {id}
+
+                      <button
+                        className="panel__content__form__section__list__item__remove-btn"
+                        disabled={dataProductEditorState.isReadOnly}
+                        onClick={() => handleRemoveId(expertise, id)}
+                        tabIndex={-1}
+                      >
+                        <TimesIcon />
+                      </button>
+                    </div>
+                  ))}
+                </div>
+                <NewExpertIdComponent expertise={expertise} />
+              </div>
+              <div className="data-product-editor__expertise__actions">
+                <button
+                  className="access-point-editor__generic-entry__remove-btn--group"
+                  onClick={() => {
+                    handleRemoveExpertise(expertise);
+                  }}
+                  tabIndex={-1}
+                  title="Remove Expertise"
+                >
+                  <TimesIcon />
+                </button>
+              </div>
+            </div>
+          </>
+        ))}
+      </>
+    );
+  },
+);
+
 const SupportTab = observer(
   (props: {
     dataProductEditorState: DataProductEditorState;
@@ -2192,6 +2336,7 @@ const SupportTab = observer(
           isReadOnly={isReadOnly}
           emptyMessage="No emails specified"
         />
+        <ExpertiseEditor dataProductEditorState={dataProductEditorState} />
       </div>
     );
   },
@@ -2201,6 +2346,7 @@ const getDataProductViewerState = (
   product: DataProduct,
   graphManagerState: GraphManagerState,
   applicationStore: LegendStudioApplicationStore,
+  depotServerClient: DepotServerClient,
 ) => {
   const graphManager = guaranteeType(
     graphManagerState.graphManager,
@@ -2211,16 +2357,19 @@ const getDataProductViewerState = (
     V1_DataProduct,
   );
   const remoteEngine = guaranteeType(graphManager.engine, V1_RemoteEngine);
-  return new DataProductViewerState(
+  const dataProductViewerState = new DataProductViewerState(
     v1_dataProduct,
     applicationStore,
     remoteEngine.getEngineServerClient(),
+    depotServerClient,
     graphManagerState,
     applicationStore.config.options.dataProductConfig,
     undefined,
     undefined,
     {},
   );
+  dataProductViewerState.init();
+  return dataProductViewerState;
 };
 
 export const DataProductEditor = observer(() => {
@@ -2230,14 +2379,9 @@ export const DataProductEditor = observer(() => {
   const product = dataProductEditorState.product;
   const isReadOnly = dataProductEditorState.isReadOnly;
   const auth = useAuth();
-  const [showPreview, setshowPreview] = useState(false);
-  const [dataProductViewerState, setDataProductViewerState] = useState(
-    getDataProductViewerState(
-      product,
-      editorStore.graphManagerState,
-      editorStore.applicationStore,
-    ),
-  );
+  const [showPreview, setShowPreview] = useState(false);
+  const [dataProductViewerState, setDataProductViewerState] =
+    useState<DataProductViewerState>();
 
   const deployDataProduct = (): void => {
     // Trigger OAuth flow if not authenticated
@@ -2319,6 +2463,7 @@ export const DataProductEditor = observer(() => {
                 product,
                 editorStore.graphManagerState,
                 editorStore.applicationStore,
+                editorStore.depotServerClient,
               ),
             );
           }
@@ -2328,6 +2473,7 @@ export const DataProductEditor = observer(() => {
     [
       editorStore.applicationStore,
       editorStore.graphManagerState,
+      editorStore.depotServerClient,
       product,
       showPreview,
     ],
@@ -2349,7 +2495,21 @@ export const DataProductEditor = observer(() => {
             <div className="btn__dropdown-combo btn__dropdown-combo--primary">
               <button
                 className="btn__dropdown-combo__label"
-                onClick={() => setshowPreview(!showPreview)}
+                onClick={() => {
+                  setShowPreview((prev) => {
+                    if (!prev) {
+                      setDataProductViewerState(
+                        getDataProductViewerState(
+                          product,
+                          editorStore.graphManagerState,
+                          editorStore.applicationStore,
+                          editorStore.depotServerClient,
+                        ),
+                      );
+                    }
+                    return !prev;
+                  });
+                }}
                 title={showPreview ? 'Hide Preview' : 'Preview Description'}
                 tabIndex={-1}
                 style={{
@@ -2396,8 +2556,10 @@ export const DataProductEditor = observer(() => {
           <DataProductSidebar dataProductEditorState={dataProductEditorState} />
           <ResizablePanelGroup orientation="vertical">
             <ResizablePanel>{renderActivivtyBarTab()}</ResizablePanel>
-            {showPreview && <ResizablePanelSplitter />}
-            {showPreview && (
+            {showPreview && dataProductViewerState && (
+              <ResizablePanelSplitter />
+            )}
+            {showPreview && dataProductViewerState && (
               <ResizablePanel>
                 <div className="data-product-editor__preview-container theme__hc-light">
                   <ProductViewer productViewerState={dataProductViewerState} />

package/src/stores/editor/editor-state/ExternalFormatState.ts

@@ -36,6 +36,7 @@ export enum EmbeddedDataType {
   MODEL_STORE_DATA = 'MODEL_STORE',
   RELATIONAL_CSV = 'RELATIONAL',
   DATA_ELEMENT = 'DATA_ELEMENT',
+  RELATION_ELEMENTS_DATA = 'RELATION_ELEMENTS_DATA',
 }
 
 export class ExternalFormatState {

package/src/stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.ts

@@ -24,6 +24,11 @@ import {
   ExternalFormatData,
   ModelStoreData,
   ModelEmbeddedData,
+  type RelationElement,
+  RelationElementsData,
+  RelationRowTestData,
+  observe_RelationRowTestData,
+  observe_RelationElement,
 } from '@finos/legend-graph';
 import {
   ContentType,
@@ -64,6 +69,9 @@ export const createEmbeddedData = (
   } else if (type === EmbeddedDataType.RELATIONAL_CSV) {
     const relational = new RelationalCSVData();
     return relational;
+  } else if (type === EmbeddedDataType.RELATION_ELEMENTS_DATA) {
+    const testData = new RelationElementsData();
+    return testData;
   } else if (type === EmbeddedDataType.MODEL_STORE_DATA) {
     const modelStoreData = new ModelStoreData();
     return modelStoreData;
@@ -201,6 +209,229 @@ export class ModelStoreDataState extends EmbeddedDataState {
   }
 }
 
+export class RelationElementState {
+  relationElement: RelationElement;
+
+  constructor(relationElement: RelationElement) {
+    makeObservable(this, {
+      relationElement: observable,
+      addColumn: action,
+      removeColumn: action,
+      updateColumn: action,
+      addRow: action,
+      removeRow: action,
+      updateRow: action,
+      clearAllData: action,
+      importCSV: action,
+    });
+    this.relationElement = relationElement;
+    this.relationElement = observe_RelationElement(relationElement);
+  }
+
+  addColumn(name: string): void {
+    this.relationElement.columns.push(name);
+    this.relationElement.rows.forEach((row) => {
+      row.values.push('');
+    });
+  }
+
+  removeColumn(index: number): void {
+    const columnToRemove = this.relationElement.columns[index];
+    if (columnToRemove) {
+      this.relationElement.columns.splice(index, 1);
+      this.relationElement.rows.forEach((row) => {
+        row.values.splice(index, 1);
+      });
+    }
+  }
+
+  updateColumn(index: number, name: string): void {
+    const oldName = this.relationElement.columns[index];
+    if (oldName && oldName !== name) {
+      this.relationElement.columns[index] = name;
+    }
+  }
+
+  addRow(): void {
+    const row = new RelationRowTestData();
+    row.values = [];
+    const newRow = observe_RelationRowTestData(row);
+    this.relationElement.columns.forEach((col) => {
+      newRow.values.push('');
+    });
+    this.relationElement.rows.push(newRow);
+  }
+
+  removeRow(index: number): void {
+    this.relationElement.rows.splice(index, 1);
+  }
+
+  updateRow(rowIndex: number, columnIndex: number, value: string): void {
+    if (this.relationElement.rows[rowIndex]) {
+      this.relationElement.rows[rowIndex].values[columnIndex] = value;
+    }
+  }
+
+  clearAllData(): void {
+    this.relationElement.rows.splice(0);
+  }
+
+  exportJSON(): string {
+    return JSON.stringify(
+      {
+        columns: this.relationElement.columns,
+        data: this.relationElement.rows,
+      },
+      null,
+      2,
+    );
+  }
+
+  exportSQL(): string {
+    if (
+      this.relationElement.columns.length === 0 ||
+      this.relationElement.rows.length === 0
+    ) {
+      return '';
+    }
+
+    const tableName = 'test_data';
+    const defaultDataType = 'VARCHAR(1000)';
+    const columnDefs = this.relationElement.columns
+      .map((col) => `${col} ${defaultDataType}`)
+      .join(', ');
+    const createTable = `CREATE TABLE ${tableName} (${columnDefs});`;
+
+    const insertStatements = this.relationElement.rows.map((row) => {
+      const values = this.relationElement.columns
+        .map((col, colIndex) => {
+          const value = row.values[colIndex] ?? '';
+          if (value !== '') {
+            return `'${value.replace(/'/g, "''")}'`;
+          }
+          return 'NULL';
+        })
+        .join(', ');
+      return `INSERT INTO ${tableName} VALUES (${values});`;
+    });
+
+    return [createTable, '', ...insertStatements].join('\n');
+  }
+
+  exportCSV(): string {
+    const headers = this.relationElement.columns.map((col) => col);
+    const csvLines = [headers.join(',')];
+
+    this.relationElement.rows.forEach((row) => {
+      const values = headers.map((header, headerIndex) => {
+        const value = row.values[headerIndex] ?? '';
+        if (value.includes(',') || value.includes('"')) {
+          return `"${value.replace(/"/g, '""')}"`;
+        }
+        return value;
+      });
+      csvLines.push(values.join(','));
+    });
+
+    return csvLines.join('\n');
+  }
+
+  private parseCSVLine(line: string): string[] {
+    const result: string[] = [];
+    let current = '';
+    let inQuotes = false;
+
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"') {
+        inQuotes = !inQuotes;
+      } else if (char === ',' && !inQuotes) {
+        result.push(current.trim());
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+    result.push(current.trim());
+    return result;
+  }
+
+  importCSV(csvContent: string): void {
+    const lines = csvContent.trim().split('\n');
+    if (lines.length === 0) {
+      return;
+    }
+
+    const firstLine = lines[0];
+    if (!firstLine) {
+      return;
+    }
+
+    const headers = this.parseCSVLine(firstLine);
+    this.relationElement.columns = headers;
+
+    this.relationElement.rows = lines.slice(1).map((line) => {
+      const values = this.parseCSVLine(line);
+      const row = new RelationRowTestData();
+      row.values = [];
+      headers.forEach((header, index) => {
+        row.values[index] = values[index] ?? '';
+      });
+      return observe_RelationRowTestData(row);
+    });
+  }
+}
+
+export class RelationElementsDataState extends EmbeddedDataState {
+  override embeddedData: RelationElementsData;
+  showImportCSVModal = false;
+  showNewRelationElementModal = false;
+  activeRelationElement: RelationElementState | undefined;
+  relationElementStates: RelationElementState[];
+
+  constructor(editorStore: EditorStore, embeddedData: RelationElementsData) {
+    super(editorStore, embeddedData);
+    makeObservable(this, {
+      embeddedData: observable,
+      showImportCSVModal: observable,
+      showNewRelationElementModal: observable,
+      activeRelationElement: observable,
+      setActiveRelationElement: action,
+      setShowImportCSVModal: action,
+      setShowNewRelationElementModal: action,
+      addRelationElement: action,
+    });
+    this.embeddedData = embeddedData;
+    this.relationElementStates = embeddedData.relationElements.map(
+      (relationElement) => new RelationElementState(relationElement),
+    );
+    this.activeRelationElement = this.relationElementStates[0];
+  }
+
+  label(): string {
+    return 'Relation Elements Test Data';
+  }
+
+  setActiveRelationElement(val: RelationElementState | undefined): void {
+    this.activeRelationElement = val;
+  }
+
+  addRelationElement(relationElement: RelationElement): void {
+    const newElementState = new RelationElementState(relationElement);
+    this.relationElementStates.push(newElementState);
+    this.embeddedData.relationElements.push(relationElement);
+    this.setActiveRelationElement(newElementState);
+  }
+
+  setShowImportCSVModal(show: boolean): void {
+    this.showImportCSVModal = show;
+  }
+
+  setShowNewRelationElementModal(show: boolean): void {
+    this.showNewRelationElementModal = show;
+  }
+}
+
 export class RelationalCSVDataTableState {
   readonly editorStore: EditorStore;
   table: RelationalCSVDataTable;
@@ -374,6 +605,8 @@ export function buildEmbeddedDataEditorState(
     );
   } else if (embeddedData instanceof RelationalCSVData) {
     return new RelationalCSVDataState(editorStore, embeddedData);
+  } else if (embeddedData instanceof RelationElementsData) {
+    return new RelationElementsDataState(editorStore, embeddedData);
   } else if (embeddedData instanceof DataElementReference) {
     return new DataElementReferenceState(editorStore, embeddedData, options);
   } else {

package/src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts

@@ -43,6 +43,7 @@ import {
   DataProductRuntimeInfo,
   type DataProductElement,
   type Mapping,
+  Expertise,
   observe_DataProductElementScope,
   DataProductElementScope,
   validate_PureExecutionMapping,
@@ -78,6 +79,7 @@ import {
   accessPointGroup_swapAccessPoints,
   dataProduct_addAccessPoint,
   dataProduct_addAccessPointGroup,
+  dataProduct_addExpertise,
   dataProduct_deleteAccessPoint,
   dataProduct_deleteAccessPointGroup,
   dataProduct_swapAccessPointGroups,
@@ -726,6 +728,11 @@ export class DataProductEditorState extends ElementEditorState {
     });
   }
 
+  createExpertise() {
+    const newExpertise = new Expertise();
+    dataProduct_addExpertise(this.product, newExpertise);
+  }
+
   *deploy(token: string | undefined): GeneratorFn<void> {
     try {
       assertTrue(

package/src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts

@@ -54,12 +54,13 @@ import {
   InstanceValue,
   PackageableElementReference,
   Database,
-  RelationalCSVData,
   PackageableElementExplicitReference,
   observe_ValueSpecification,
   buildLambdaVariableExpressions,
   EqualTo,
   ModelStore,
+  RelationElementsData,
+  CORE_PURE_PATH,
 } from '@finos/legend-graph';
 import {
   TestablePackageableElementEditorState,
@@ -122,7 +123,14 @@ const resolveRuntimesFromQuery = (
 ): EngineRuntime[] | undefined => {
   try {
     const body = func.expressionSequence;
-    const rawLambda = new RawLambda([], body);
+    const rawLambda = new RawLambda(
+      func.parameters.map((_param) =>
+        editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
+          _param,
+        ),
+      ),
+      body,
+    );
     const functions = new Map<string, SimpleFunctionExpression[]>();
     const valueSpec =
       editorStore.graphManagerState.graphManager.buildValueSpecification(
@@ -759,7 +767,18 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
     const functionSuite = new FunctionTestSuite();
     functionSuite.id = suiteName;
     const engineRuntimes = this.associatedRuntimes;
-    if (engineRuntimes?.length) {
+    if (!engineRuntimes?.length) {
+      const type = this.function.returnType.value.rawType;
+      if (
+        type.path === CORE_PURE_PATH.RELATION ||
+        type.path === CORE_PURE_PATH.TABULAR_DATASET
+      ) {
+        this.editorStore.applicationStore.notificationService.notifyWarning(
+          `Unable to find runtime or function contains accessors incompatible for test suite creation`,
+        );
+        return;
+      }
+    } else {
       try {
         assertTrue(
           engineRuntimes.length === 1,
@@ -791,9 +810,9 @@ export class FunctionTestableState extends TestablePackageableElementEditorState
         const store = guaranteeNonNullable(stores[0]);
         const data = new FunctionTestData();
         if (store instanceof Database) {
-          const relational = new RelationalCSVData();
+          const relation = new RelationElementsData();
           data.element = PackageableElementExplicitReference.create(store);
-          data.data = relational;
+          data.data = relation;
         } else if (store instanceof ModelStore) {
           const modelStoreData = createBareExternalFormat();
           data.element = PackageableElementExplicitReference.create(store);