@finos/legend-application-studio 28.21.45 → 28.21.47

package/src/stores/editor/sidebar-state/WorkspaceReviewState.ts

@@ -25,6 +25,11 @@ import {
 import type { EditorStore } from '../EditorStore.js';
 import type { EditorSDLCState } from '../EditorSDLCState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  SDLC_REVIEW_ACTION,
+  SDLC_REVIEW_ROLE,
+} from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import { LegendStudioUserDataHelper } from '../../../__lib__/LegendStudioUserDataHelper.js';
 import {
   type GeneratorFn,
@@ -287,6 +292,22 @@ export class WorkspaceReviewState {
       return;
     }
     this.isClosingWorkspaceReview = true;
+    const startTime = Date.now();
+    const reviewId = this.workspaceReview.id;
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const identity = {
+      action: SDLC_REVIEW_ACTION.CLOSE,
+      role: SDLC_REVIEW_ROLE.AUTHOR,
+      projectId: this.sdlcState.activeProject.projectId,
+      patchReleaseVersionId:
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
+      reviewId,
+    };
+    LegendStudioTelemetryHelper.logEvent_SdlcReviewActionLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      identity,
+    );
     try {
       yield this.editorStore.sdlcServerClient.rejectReview(
         this.sdlcState.activeProject.projectId,
@@ -294,12 +315,22 @@ export class WorkspaceReviewState {
         this.workspaceReview.id,
       );
       this.workspaceReview = undefined;
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...identity, durationMs: Date.now() - startTime },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...identity, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.isClosingWorkspaceReview = false;
@@ -332,6 +363,20 @@ export class WorkspaceReviewState {
       return;
     }
     this.isCreatingWorkspaceReview = true;
+    const startTime = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const identity = {
+      action: SDLC_REVIEW_ACTION.CREATE,
+      role: SDLC_REVIEW_ROLE.AUTHOR,
+      projectId: this.sdlcState.activeProject.projectId,
+      patchReleaseVersionId:
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
+    };
+    LegendStudioTelemetryHelper.logEvent_SdlcReviewActionLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      identity,
+    );
     try {
       const description =
         reviewDescription ??
@@ -348,12 +393,26 @@ export class WorkspaceReviewState {
           },
         )) as PlainObject<Review>,
       );
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        {
+          ...identity,
+          reviewId: this.workspaceReview.id,
+          durationMs: Date.now() - startTime,
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...identity, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.isCreatingWorkspaceReview = false;
@@ -396,6 +455,21 @@ export class WorkspaceReviewState {
       return;
     }
 
+    const startTime = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const identity = {
+      action: SDLC_REVIEW_ACTION.COMMIT,
+      role: SDLC_REVIEW_ROLE.AUTHOR,
+      projectId: this.sdlcState.activeProject.projectId,
+      patchReleaseVersionId:
+        this.sdlcState.activePatch?.patchReleaseVersionId.id,
+      reviewId: review.id,
+    };
+    LegendStudioTelemetryHelper.logEvent_SdlcReviewActionLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      identity,
+    );
     try {
       yield this.editorStore.sdlcServerClient.commitReview(
         this.sdlcState.activeProject.projectId,
@@ -403,6 +477,11 @@ export class WorkspaceReviewState {
         review.id,
         { message: `${review.title} [review]` },
       );
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...identity, durationMs: Date.now() - startTime },
+      );
       // Committing a review deletes the workspace on SDLC. Drop it from
       // the recents cache so the workspace setup screen doesn't keep
       // offering a dead link. Patch workspaces are never cached.
@@ -452,6 +531,11 @@ export class WorkspaceReviewState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.SDLC_MANAGER_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_SdlcReviewActionFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...identity, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.isCommittingWorkspaceReview = false;

package/src/stores/editor/sidebar-state/testable/GlobalTestRunnerState.ts

@@ -54,6 +54,14 @@ import type {
 } from '../../../LegendStudioApplicationPlugin.js';
 import { ServiceEditorState } from '../../editor-state/element-editor-state/service/ServiceEditorState.js';
 import { LegendStudioUserDataHelper } from '../../../../__lib__/LegendStudioUserDataHelper.js';
+import {
+  GLOBAL_TEST_RUN_SCOPE,
+  LegendStudioTelemetryHelper,
+  TESTABLE_RUN_MODE,
+  getTestableKind,
+  getTestablePath,
+  summarizeTestResults,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
 
 // Testable Metadata
 export interface TestableMetadata {
@@ -456,6 +464,10 @@ export class TestableState {
     this.isRunningTests.inProgress();
     let input: RunTestsTestableInput;
     let currentNode = node;
+    const testable = this.testableMetadata.testable;
+    let mode: TESTABLE_RUN_MODE = TESTABLE_RUN_MODE.RUN_TESTABLE;
+    let suiteId: string | undefined;
+    let testCount = 0;
     try {
       if (node instanceof AssertionTestTreeNodeData) {
         const atomicTest = guaranteeNonNullable(node.assertion.parentTest);
@@ -463,8 +475,11 @@ export class TestableState {
           atomicTest.__parent instanceof TestSuite
             ? atomicTest.__parent
             : undefined;
-        input = new RunTestsTestableInput(this.testableMetadata.testable);
+        input = new RunTestsTestableInput(testable);
         input.unitTestIds = [new UniqueTestId(suite, atomicTest)];
+        mode = TESTABLE_RUN_MODE.RUN_TEST;
+        suiteId = suite?.id;
+        testCount = 1;
         const parentNode = Array.from(this.treeData.nodes.values())
           .filter(filterByType(AtomicTestTreeNodeData))
           .find((n) => n.atomicTest === atomicTest);
@@ -478,30 +493,74 @@ export class TestableState {
           atomicTest.__parent instanceof TestSuite
             ? atomicTest.__parent
             : undefined;
-        input = new RunTestsTestableInput(this.testableMetadata.testable);
+        input = new RunTestsTestableInput(testable);
         input.unitTestIds = [new UniqueTestId(suite, atomicTest)];
+        mode = TESTABLE_RUN_MODE.RUN_TEST;
+        suiteId = suite?.id;
+        testCount = 1;
         node.isRunning = true;
       } else if (node instanceof TestSuiteTreeNodeData) {
-        input = new RunTestsTestableInput(this.testableMetadata.testable);
+        input = new RunTestsTestableInput(testable);
         input.unitTestIds = node.testSuite.tests.map(
           (s) => new UniqueTestId(node.testSuite, s),
         );
+        mode = TESTABLE_RUN_MODE.RUN_SUITE;
+        suiteId = node.testSuite.id;
+        testCount = node.testSuite.tests.length;
         node.isRunning = true;
       } else if (node instanceof TestableTreeNodeData) {
-        input = new RunTestsTestableInput(this.testableMetadata.testable);
+        input = new RunTestsTestableInput(testable);
+        mode = TESTABLE_RUN_MODE.RUN_TESTABLE;
+        suiteId = undefined;
+        testCount = testable.tests.reduce(
+          (acc, t) => acc + (t instanceof TestSuite ? t.tests.length : 1),
+          0,
+        );
         node.isRunning = true;
       } else {
         throw new UnsupportedOperationError(
           `Unable to run tests for node ${node}`,
         );
       }
-      const testResults =
-        (yield this.editorStore.graphManagerState.graphManager.runTests(
-          [input],
-          this.editorStore.graphManagerState.graph,
-        )) as TestResult[];
-      this.globalTestRunnerState.handleResults(testResults);
-      this.isRunningTests.complete();
+      const telemetryBase = {
+        testableKind: getTestableKind(testable),
+        testablePath: getTestablePath(testable),
+        suiteId,
+        mode,
+        testCount,
+      };
+      const startTime = Date.now();
+      LegendStudioTelemetryHelper.logEvent_TestableRunLaunched(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        telemetryBase,
+      );
+      try {
+        const testResults =
+          (yield this.editorStore.graphManagerState.graphManager.runTests(
+            [input],
+            this.editorStore.graphManagerState.graph,
+          )) as TestResult[];
+        this.globalTestRunnerState.handleResults(testResults);
+        this.isRunningTests.complete();
+        LegendStudioTelemetryHelper.logEvent_TestableRunSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          {
+            ...telemetryBase,
+            durationMs: Date.now() - startTime,
+            ...summarizeTestResults(testResults),
+          },
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        LegendStudioTelemetryHelper.logEvent_TestableRunFailure(
+          this.editorStore.applicationStore.telemetryService,
+          this.editorStore.editorMode.getSourceInfo(),
+          { ...telemetryBase, errorMessage: error.message },
+        );
+        throw error;
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
@@ -659,11 +718,21 @@ export class GlobalTestRunnerState {
   }
 
   *runAllTests(): GeneratorFn<void> {
+    const inputs = this.ownTestableStates.map(
+      (e) => new RunTestsTestableInput(e.testableMetadata.testable),
+    );
+    const telemetryBase = {
+      scope: GLOBAL_TEST_RUN_SCOPE.ALL,
+      testableCount: inputs.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_GlobalTestRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.isRunningTests.inProgress();
-      const inputs = this.ownTestableStates.map(
-        (e) => new RunTestsTestableInput(e.testableMetadata.testable),
-      );
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           inputs,
@@ -671,10 +740,24 @@ export class GlobalTestRunnerState {
         )) as TestResult[];
       this.handleResults(testResults);
       this.isRunningTests.complete();
+      LegendStudioTelemetryHelper.logEvent_GlobalTestRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.isRunningTests.fail();
+      LegendStudioTelemetryHelper.logEvent_GlobalTestRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     }
   }
 
@@ -711,11 +794,21 @@ export class GlobalTestRunnerState {
   }
 
   *runDependenciesTests(): GeneratorFn<void> {
+    const inputs = this.allDependencyTestablesStates.map(
+      (e) => new RunTestsTestableInput(e.testableMetadata.testable),
+    );
+    const telemetryBase = {
+      scope: GLOBAL_TEST_RUN_SCOPE.DEPENDENCIES,
+      testableCount: inputs.length,
+    };
+    const startTime = Date.now();
+    LegendStudioTelemetryHelper.logEvent_GlobalTestRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      this.editorStore.editorMode.getSourceInfo(),
+      telemetryBase,
+    );
     try {
       this.isRunningDependencyTests.inProgress();
-      const inputs = this.allDependencyTestablesStates.map(
-        (e) => new RunTestsTestableInput(e.testableMetadata.testable),
-      );
       const testResults =
         (yield this.editorStore.graphManagerState.graphManager.runTests(
           inputs,
@@ -723,10 +816,24 @@ export class GlobalTestRunnerState {
         )) as TestResult[];
       this.handleResults(testResults);
       this.isRunningDependencyTests.complete();
+      LegendStudioTelemetryHelper.logEvent_GlobalTestRunSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        {
+          ...telemetryBase,
+          durationMs: Date.now() - startTime,
+          ...summarizeTestResults(testResults),
+        },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);
       this.isRunningDependencyTests.fail();
+      LegendStudioTelemetryHelper.logEvent_GlobalTestRunFailure(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        { ...telemetryBase, errorMessage: error.message },
+      );
     }
   }
 }

package/src/stores/editor/utils/MockDataUtils.ts

@@ -21,7 +21,6 @@ import {
   Randomizer,
   UnsupportedOperationError,
   type PlainObject,
-  isNonNullable,
   filterByType,
 } from '@finos/legend-shared';
 import type { EditorStore } from '../EditorStore.js';
@@ -37,16 +36,12 @@ import {
   TableAlias,
   Table,
   Column,
-  VarChar,
   type RelationalDataType,
-  Char,
-  VarBinary,
+  BigInt,
   TinyInt,
   Float,
   Timestamp,
-  Binary,
   Bit,
-  Other,
   Numeric,
   Decimal,
   Double,
@@ -220,49 +215,56 @@ export const createMockDataForClassWithFormat = (
   }
 };
 
+/**
+ * Maps a relational column type to the standard primitive type used to read
+ * the column with a TDS getter (e.g. `$row.getFloat('COL')`) and to mock its
+ * values.
+ *
+ * NOTE: this matches how the engine types `tableToTDS()` columns, except that
+ * `DECIMAL` and `NUMERIC` map to `Decimal` (the engine uses `Float`), so mock
+ * values keep exact-numeric semantics. Binary, JSON, semi-structured and other
+ * types have no TDS getter or literal of their own and map to `String`.
+ */
 export const getPrimitiveTypeFromRelationalType = (
   type: RelationalDataType,
-): PrimitiveType | undefined => {
-  if (
-    type instanceof VarChar ||
-    type instanceof Char ||
-    type instanceof VarBinary ||
-    type instanceof Binary ||
-    type instanceof Bit ||
-    type instanceof Other
-  ) {
-    return PrimitiveType.STRING;
-  } else if (type instanceof Numeric) {
-    return PrimitiveType.NUMBER;
-  } else if (type instanceof Decimal) {
-    return PrimitiveType.DECIMAL;
+): PrimitiveType => {
+  if (type instanceof Bit) {
+    return PrimitiveType.BOOLEAN;
   } else if (
-    type instanceof Double ||
     type instanceof Integer ||
-    type instanceof Real ||
+    type instanceof BigInt ||
     type instanceof SmallInt ||
     type instanceof TinyInt
   ) {
     return PrimitiveType.INTEGER;
-  } else if (type instanceof Float) {
+  } else if (
+    type instanceof Float ||
+    type instanceof Double ||
+    type instanceof Real
+  ) {
     return PrimitiveType.FLOAT;
+  } else if (type instanceof Decimal || type instanceof Numeric) {
+    return PrimitiveType.DECIMAL;
   } else if (type instanceof ColumnDate) {
-    return PrimitiveType.DATE;
+    return PrimitiveType.STRICTDATE;
   } else if (type instanceof Timestamp) {
     return PrimitiveType.DATETIME;
   }
-  return undefined;
+  // VARCHAR, CHAR, BINARY, VARBINARY, JSON, SEMISTRUCTURED, OTHER
+  return PrimitiveType.STRING;
 };
+
 export const createMockDataForColumn = (
   col: Column,
   isPrimaryKey: boolean,
   idx?: number | undefined,
-): string | undefined => {
+): string => {
   const type = col.type;
 
   if (
     (type instanceof Double ||
       type instanceof Integer ||
+      type instanceof BigInt ||
       type instanceof Real ||
       type instanceof SmallInt ||
       type instanceof TinyInt) &&
@@ -271,13 +273,13 @@ export const createMockDataForColumn = (
   ) {
     return idx.toString();
   }
-  const primitive = getPrimitiveTypeFromRelationalType(type);
-  if (primitive) {
-    return createMockPrimitiveProperty(primitive, col.name).toString();
-  } else if (type instanceof Json || type instanceof SemiStructured) {
+  if (type instanceof Json || type instanceof SemiStructured) {
     return '{}';
   }
-  return undefined;
+  return createMockPrimitiveProperty(
+    getPrimitiveTypeFromRelationalType(type),
+    col.name,
+  ).toString();
 };
 
 export const createMockDataForTable = (
@@ -292,7 +294,6 @@ export const createMockDataForTable = (
         .map((col) =>
           createMockDataForColumn(col, table.primaryKey.includes(col), idx),
         )
-        .filter(isNonNullable)
         .join(','),
     )
     .join('\n');

package/src/stores/graph-modifier/DSL_DataProduct_GraphModifierHelper.ts

@@ -104,6 +104,24 @@ export const accessPointGroup_setTitle = action(
   },
 );
 
+export const accessPointGroup_addTarget = action(
+  (group: AccessPointGroup, target: string) => {
+    if (!group.targets) {
+      group.targets = [target];
+    } else {
+      addUniqueEntry(group.targets, target);
+    }
+  },
+);
+
+export const accessPointGroup_deleteTarget = action(
+  (group: AccessPointGroup, target: string) => {
+    if (group.targets) {
+      deleteEntry(group.targets, target);
+    }
+  },
+);
+
 export const modelAccessPointGroup_setMapping = action(
   (
     group: ModelAccessPointGroup,

package/src/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.ts

@@ -17,10 +17,14 @@
 import {
   ConnectionPointer,
   type PackageableConnection,
+  type PackageableRuntime,
+  type ObserverContext,
   PackageableElementExplicitReference,
-  type LakehouseRuntime,
+  LakehouseRuntime,
+  LakehouseSingleStoreRuntime,
 } from '@finos/legend-graph';
 import { action } from 'mobx';
+import { packageableRuntime_setRuntimeValue } from './DSL_Mapping_GraphModifierHelper.js';
 
 export const lakehouseRuntime_setWarehouse = action(
   (runtime: LakehouseRuntime, warehouse: string | undefined) => {
@@ -28,12 +32,6 @@ export const lakehouseRuntime_setWarehouse = action(
   },
 );
 
-export const lakehouseRuntime_setEnvironment = action(
-  (runtime: LakehouseRuntime, environment: string | undefined) => {
-    runtime.environment = environment;
-  },
-);
-
 export const lakehouseRuntime_setConnection = action(
   (
     runtime: LakehouseRuntime,
@@ -47,3 +45,60 @@ export const lakehouseRuntime_setConnection = action(
         : undefined;
   },
 );
+
+export enum LakehouseComputeEngine {
+  SNOWFLAKE = 'SNOWFLAKE',
+  SINGLE_STORE = 'SINGLE_STORE',
+}
+
+/**
+ * Vendor product names, so they are spelled the way the vendor spells them --
+ * `prettyCONSTName` cannot produce "SingleStore" from any all-caps constant.
+ */
+export const LAKEHOUSE_COMPUTE_ENGINE_LABEL: Record<
+  LakehouseComputeEngine,
+  string
+> = {
+  [LakehouseComputeEngine.SNOWFLAKE]: 'Snowflake',
+  [LakehouseComputeEngine.SINGLE_STORE]: 'SingleStore',
+};
+
+export const getLakehouseComputeEngine = (
+  runtimeValue: LakehouseRuntime | LakehouseSingleStoreRuntime,
+): LakehouseComputeEngine =>
+  runtimeValue instanceof LakehouseRuntime
+    ? LakehouseComputeEngine.SNOWFLAKE
+    : LakehouseComputeEngine.SINGLE_STORE;
+
+/**
+ * Swaps the concrete Lakehouse runtime class backing `packageableRuntime`
+ * between `LakehouseRuntime` (Snowflake) and `LakehouseSingleStoreRuntime`.
+ * These are distinct classes with distinct wire `_type`s, not a flag on one
+ * class, so switching compute engine means constructing a new instance --
+ * `environment` carries over, `warehouse`/`connectionPointer` naturally fall
+ * away (or reset to undefined) since the target class may not have them.
+ */
+export const lakehouseRuntime_setComputeEngine = action(
+  (
+    packageableRuntime: PackageableRuntime,
+    computeEngine: LakehouseComputeEngine,
+    observerContext: ObserverContext,
+  ): LakehouseRuntime | LakehouseSingleStoreRuntime => {
+    const current = packageableRuntime.runtimeValue;
+    const environment =
+      current instanceof LakehouseRuntime ||
+      current instanceof LakehouseSingleStoreRuntime
+        ? current.environment
+        : undefined;
+    const next =
+      computeEngine === LakehouseComputeEngine.SNOWFLAKE
+        ? new LakehouseRuntime(environment)
+        : new LakehouseSingleStoreRuntime(environment);
+    packageableRuntime_setRuntimeValue(
+      packageableRuntime,
+      next,
+      observerContext,
+    );
+    return next;
+  },
+);