@finos/legend-application-studio 28.21.45 → 28.21.47

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

@@ -52,6 +52,10 @@ import { ExternalFormatState } from './ExternalFormatState.js';
 import { ExplorerTreeRootPackageLabel } from '../ExplorerTreeState.js';
 import type { DSL_Generation_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Generation_LegendStudioApplicationPlugin_Extension.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  GENERATION_MODE,
+  LegendStudioTelemetryHelper,
+} from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import {
   FileSystem_Directory,
   type FileSystemTreeNodeData,
@@ -149,15 +153,19 @@ export class DEPREACTED_GlobalFileGenerationState {
   /**
    * Generated file generations in the graph.
    * NOTE: This method does not update graph and application only the files are generated.
+   *
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown so the caller can keep generating; the caller owns the
+   * `editor.generation.*` telemetry outcome.
    */
   *DEPREACTED_generateFiles(
     generationOutputIndex: Map<string, GenerationOutput[]>,
-  ): GeneratorFn<void> {
+  ): GeneratorFn<Error | undefined> {
     try {
       const generationSpecs =
         this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
       if (!generationSpecs.length) {
-        return;
+        return undefined;
       }
       assertTrue(
         generationSpecs.length === 1,
@@ -188,6 +196,7 @@ export class DEPREACTED_GlobalFileGenerationState {
         }
         generationOutputIndex.set(fileGeneration.value.path, result);
       }
+      return undefined;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -197,6 +206,7 @@ export class DEPREACTED_GlobalFileGenerationState {
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 
@@ -310,15 +320,53 @@ export class GraphGenerationState {
       return;
     }
     this.isRunningGlobalGenerate = true;
+    const startedAt = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const telemetryBase = {
+      mode: GENERATION_MODE.GLOBAL,
+      enableArtifactGeneration: this.enableArtifactGeneration,
+    };
+    LegendStudioTelemetryHelper.logEvent_GenerationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      telemetryBase,
+    );
     try {
-      yield flowResult(this.generateModels());
-      yield flowResult(this.generateArtifacts());
+      // NOTE: both steps handle (log + notify) their own errors and return
+      // them instead of throwing, so artifact generation still runs when
+      // model generation fails. We only decide the telemetry outcome here so
+      // each run emits exactly one terminal event.
+      const modelGenerationError = (yield flowResult(this.generateModels())) as
+        | Error
+        | undefined;
+      const artifactGenerationError = (yield flowResult(
+        this.generateArtifacts(),
+      )) as Error | undefined;
+      const generationError = modelGenerationError ?? artifactGenerationError;
+      if (generationError) {
+        LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+          this.editorStore.applicationStore.telemetryService,
+          sourceInfo,
+          { ...telemetryBase, errorMessage: generationError.message },
+        );
+      } else {
+        LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          sourceInfo,
+          { ...telemetryBase, durationMs: Date.now() - startedAt },
+        );
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, errorMessage: error.message },
+      );
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
@@ -327,13 +375,17 @@ export class GraphGenerationState {
     }
   }
 
-  *generateModels(): GeneratorFn<void> {
+  /**
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown; see {@link GraphGenerationState.globalGenerate}.
+   */
+  *generateModels(): GeneratorFn<Error | undefined> {
     try {
       this.generatedEntities = new Map<string, Entity[]>(); // reset the map of generated entities
       const generationSpecs =
         this.editorStore.graphManagerState.graph.ownGenerationSpecifications;
       if (!generationSpecs.length) {
-        return;
+        return undefined;
       }
       assertTrue(
         generationSpecs.length === 1,
@@ -369,6 +421,7 @@ export class GraphGenerationState {
           this.editorStore.graphState.updateGenerationGraphAndApplication(),
         );
       }
+      return undefined;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -378,23 +431,27 @@ export class GraphGenerationState {
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 
   /**
    * Generated artifacts generations in graph
    * NOTE: This method does not update graph and application only the files are generated.
+   *
+   * Errors are handled (logged + notified) here and returned rather than
+   * re-thrown; see {@link GraphGenerationState.globalGenerate}.
    */
-  *generateArtifacts(): GeneratorFn<void> {
+  *generateArtifacts(): GeneratorFn<Error | undefined> {
     try {
       this.emptyGeneratedArtifacts();
       const generationOutputIndex = new Map<string, GenerationOutput[]>();
       // handle deprecated file generations
-      yield flowResult(
+      const fileGenerationError = (yield flowResult(
         this.globalFileGenerationState.DEPREACTED_generateFiles(
           generationOutputIndex,
         ),
-      );
+      )) as Error | undefined;
       let artifacts = new ArtifactGenerationExtensionResult();
       if (this.enableArtifactGeneration) {
         artifacts =
@@ -406,6 +463,7 @@ export class GraphGenerationState {
 
       // handle results
       this.processGenerationResult(artifacts, generationOutputIndex);
+      return fileGenerationError;
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(
@@ -415,6 +473,7 @@ export class GraphGenerationState {
       this.editorStore.graphState.editorStore.applicationStore.notificationService.notifyError(
         `${error.message}`,
       );
+      return error;
     }
   }
 

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

@@ -33,6 +33,7 @@ import {
   assertTrue,
 } from '@finos/legend-shared';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import { PROJECT_CONFIG_UPDATE_ACTION } from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import type { EditorStore } from '../EditorStore.js';
 import { generateGAVCoordinates, type Entity } from '@finos/legend-storage';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
@@ -379,6 +380,7 @@ export class ExecuteInputDebugModelImporterEditorState extends ModelImporterEdit
       await flowResult(
         this.editorStore.projectConfigurationEditorState.updateProjectConfiguration(
           updateProjectConfigurationCommand,
+          PROJECT_CONFIG_UPDATE_ACTION.UPDATE_CONFIGS,
         ),
       );
       // open the debugger element

package/src/stores/editor/editor-state/element-editor-state/ElementExternalFormatGenerationState.ts

@@ -37,6 +37,10 @@ import {
 import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import type { EditorStore } from '../../EditorStore.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../__lib__/LegendStudioEvent.js';
+import {
+  GENERATION_MODE,
+  LegendStudioTelemetryHelper,
+} from '../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { GENERATION_FILE_ROOT_NAME } from '../../utils/FileSystemTreeUtils.js';
 import {
   configurationProperty_addConfigurationProperty,
@@ -99,6 +103,22 @@ export class XTGenerationState extends GeneratedFileStructureState {
 
   *generate(): GeneratorFn<void> {
     this.generatingAction.inProgress();
+    const startedAt = Date.now();
+    const sourceInfo = this.editorStore.editorMode.getSourceInfo();
+    const generationType = this.elementXTSchemaGenerationState.description.name;
+    const elementPath =
+      this.configSpecification.modelUnit.packageableElementIncludes[0]?.value
+        .path;
+    const telemetryBase = {
+      mode: GENERATION_MODE.ELEMENT_SCHEMA,
+      elementPath,
+      generationType,
+    };
+    LegendStudioTelemetryHelper.logEvent_GenerationLaunched(
+      this.editorStore.applicationStore.telemetryService,
+      sourceInfo,
+      telemetryBase,
+    );
     try {
       const modelUnit = this.configSpecification.modelUnit;
       const properties = [...this.configSpecification.configurationProperties];
@@ -122,6 +142,11 @@ export class XTGenerationState extends GeneratedFileStructureState {
         )
         .flat();
       this.processGenerationResult(output);
+      LegendStudioTelemetryHelper.logEvent_GenerationSucceeded(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, durationMs: Date.now() - startedAt },
+      );
     } catch (error) {
       assertErrorThrown(error);
       this.fileSystemState.selectedNode = undefined;
@@ -130,6 +155,11 @@ export class XTGenerationState extends GeneratedFileStructureState {
         LogEvent.create(LEGEND_STUDIO_APP_EVENT.GENERATION_FAILURE),
         error,
       );
+      LegendStudioTelemetryHelper.logEvent_GenerationFailure(
+        this.editorStore.applicationStore.telemetryService,
+        sourceInfo,
+        { ...telemetryBase, errorMessage: error.message },
+      );
       this.editorStore.applicationStore.notificationService.notifyError(error);
     } finally {
       this.generatingAction.complete();

package/src/stores/editor/editor-state/element-editor-state/RuntimeEditorState.ts

@@ -68,7 +68,9 @@ import {
   isStubbed_StoreConnections,
   getAllIdentifiedConnections,
   generateIdentifiedConnectionId,
+  type LakehouseBaseRuntime,
   LakehouseRuntime,
+  LakehouseSingleStoreRuntime,
   ConcreteFunctionDefinition,
 } from '@finos/legend-graph';
 import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
@@ -899,42 +901,36 @@ export enum LakehouseRuntimeType {
   CONNECTION = 'CONNECTION',
 }
 
-export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
-  declare runtimeValue: LakehouseRuntime;
+export abstract class LakehouseBaseRuntimeEditorState extends EngineRuntimeEditorState {
+  /**
+   * NOTE: a fresh instance is built by `RuntimeEditorState.setRuntimeValueEditorState`
+   * whenever the compute engine swap replaces the concrete runtime class, so this
+   * changes exactly when that swap happens -- used to force a remount of the
+   * compute-engine-specific fields (e.g. Warehouse) in the UI.
+   */
+  readonly uuid = uuid();
+  declare runtimeValue: LakehouseBaseRuntime;
   availableEnvs: IngestDeploymentServerConfig[] | undefined;
+  /**
+   * Only `LakehouseRuntime` can switch out of environment mode today; a
+   * subclass whose runtime gains connection support just needs to set this.
+   */
   lakehouseRuntimeType = LakehouseRuntimeType.ENVIRONMENT;
 
-  constructor(state: RuntimeEditorState, value: LakehouseRuntime) {
+  constructor(state: RuntimeEditorState, value: LakehouseBaseRuntime) {
     super(state, value);
     makeObservable(this, {
       availableEnvs: observable,
+      lakehouseRuntimeType: observable,
       fetchLakehouseSummaries: flow,
       setEnvSummaries: action,
-      lakehouseRuntimeType: observable,
-      setLakehouseRuntimeType: action,
       envOptions: computed,
     });
     this.runtimeValue = value;
-    // fix when metamodel is more clear on this
-    if (value.connectionPointer) {
-      this.lakehouseRuntimeType = LakehouseRuntimeType.CONNECTION;
-    }
-  }
-
-  setLakehouseRuntimeType(val: LakehouseRuntimeType): void {
-    if (val !== this.lakehouseRuntimeType) {
-      this.lakehouseRuntimeType = val;
-      if (val === LakehouseRuntimeType.CONNECTION) {
-        this.runtimeValue.environment = undefined;
-        this.runtimeValue.warehouse = undefined;
-      } else {
-        this.setConnection(undefined);
-      }
-    }
   }
 
-  setConnection(val: PackageableConnection | undefined): void {
-    lakehouseRuntime_setConnection(this.runtimeValue, val);
+  protected get isEnvironmentModeActive(): boolean {
+    return this.lakehouseRuntimeType === LakehouseRuntimeType.ENVIRONMENT;
   }
 
   get envOptions(): { label: string; value: string }[] {
@@ -972,7 +968,7 @@ export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
         )) as unknown as IngestDeploymentServerConfig[] | undefined;
         this.setEnvSummaries(res);
         if (
-          this.lakehouseRuntimeType === LakehouseRuntimeType.ENVIRONMENT &&
+          this.isEnvironmentModeActive &&
           !this.runtimeValue.environment &&
           this.envOptions.length
         ) {
@@ -985,6 +981,40 @@ export class LakehouseRuntimeEditorState extends EngineRuntimeEditorState {
   }
 }
 
+export class LakehouseSingleStoreRuntimeEditorState extends LakehouseBaseRuntimeEditorState {
+  declare runtimeValue: LakehouseSingleStoreRuntime;
+}
+
+export class LakehouseRuntimeEditorState extends LakehouseBaseRuntimeEditorState {
+  declare runtimeValue: LakehouseRuntime;
+
+  constructor(state: RuntimeEditorState, value: LakehouseRuntime) {
+    super(state, value);
+    makeObservable(this, {
+      setLakehouseRuntimeType: action,
+    });
+    if (value.connectionPointer) {
+      this.lakehouseRuntimeType = LakehouseRuntimeType.CONNECTION;
+    }
+  }
+
+  setLakehouseRuntimeType(val: LakehouseRuntimeType): void {
+    if (val !== this.lakehouseRuntimeType) {
+      this.lakehouseRuntimeType = val;
+      if (val === LakehouseRuntimeType.CONNECTION) {
+        this.runtimeValue.environment = undefined;
+        this.runtimeValue.warehouse = undefined;
+      } else {
+        this.setConnection(undefined);
+      }
+    }
+  }
+
+  setConnection(val: PackageableConnection | undefined): void {
+    lakehouseRuntime_setConnection(this.runtimeValue, val);
+  }
+}
+
 export class RuntimeEditorState {
   /**
    * NOTE: used to force component remount on state change
@@ -1002,20 +1032,51 @@ export class RuntimeEditorState {
   ) {
     makeObservable(this, {
       runtimeValueEditorState: observable,
+      setRuntimeValueEditorState: action,
     });
 
     this.editorStore = editorStore;
     this.runtime = runtime;
     this.isEmbeddedRuntime = isEmbeddedRuntime;
-    const runtimeValue =
-      runtime instanceof RuntimePointer
-        ? runtime.packageableRuntime.value.runtimeValue
-        : guaranteeType(runtime, EngineRuntime);
-    this.runtimeValueEditorState =
-      runtimeValue instanceof LakehouseRuntime
-        ? new LakehouseRuntimeEditorState(this, runtimeValue)
+    this.runtimeValueEditorState = this.buildRuntimeValueEditorState(
+      this.resolveRuntimeValue(),
+    );
+  }
+
+  private resolveRuntimeValue(): EngineRuntime {
+    return this.runtime instanceof RuntimePointer
+      ? this.runtime.packageableRuntime.value.runtimeValue
+      : guaranteeType(this.runtime, EngineRuntime);
+  }
+
+  private buildRuntimeValueEditorState(
+    runtimeValue: EngineRuntime,
+  ): EngineRuntimeEditorState {
+    return runtimeValue instanceof LakehouseRuntime
+      ? new LakehouseRuntimeEditorState(this, runtimeValue)
+      : runtimeValue instanceof LakehouseSingleStoreRuntime
+        ? new LakehouseSingleStoreRuntimeEditorState(this, runtimeValue)
         : new EngineRuntimeEditorState(this, runtimeValue);
   }
+
+  /**
+   * Rebuilds the concrete runtime-value editor state after the underlying
+   * runtime's concrete type changes in place (e.g. Lakehouse compute-engine
+   * swap between `LakehouseRuntime` and `LakehouseSingleStoreRuntime`).
+   * Carries over already-fetched Lakehouse environment options so callers
+   * don't need to refetch (which requires an auth token round-trip).
+   */
+  setRuntimeValueEditorState(runtimeValue: EngineRuntime): void {
+    const previous = this.runtimeValueEditorState;
+    const next = this.buildRuntimeValueEditorState(runtimeValue);
+    if (
+      previous instanceof LakehouseBaseRuntimeEditorState &&
+      next instanceof LakehouseBaseRuntimeEditorState
+    ) {
+      next.setEnvSummaries(previous.availableEnvs);
+    }
+    this.runtimeValueEditorState = next;
+  }
 }
 
 export class PackageableRuntimeEditorState extends ElementEditorState {

package/src/stores/editor/editor-state/element-editor-state/availability/testable/AvailabilityTestableState.ts

@@ -50,6 +50,7 @@ import {
   TestableTestEditorState,
   TestableTestSuiteEditorState,
 } from '../../testable/TestableEditorState.js';
+import { TESTABLE_KIND } from '../../../../../../__lib__/LegendStudioTelemetryHelper.js';
 import { RelationElementState } from '../../data/EmbeddedDataState.js';
 import { atomicTest_addAssertion } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import { externalFormatData_setData } from '../../../../../graph-modifier/DSL_Data_GraphModifierHelper.js';
@@ -345,6 +346,14 @@ export class AvailabilityTestState extends TestableTestEditorState {
   readonly suiteState: AvailabilityTestSuiteState;
   override test: AvailabilityBarrierTest;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.AVAILABILITY;
+  }
+
+  override get testablePath(): string {
+    return this.suiteState.testableState.availability.path;
+  }
+
   constructor(
     suiteState: AvailabilityTestSuiteState,
     test: AvailabilityBarrierTest,
@@ -436,6 +445,14 @@ export class AvailabilityTestSuiteState extends TestableTestSuiteEditorState {
   testToRename: AvailabilityBarrierTest | undefined;
   readonly testDataState: RelationElementState;
 
+  override get testableKind(): TESTABLE_KIND {
+    return TESTABLE_KIND.AVAILABILITY;
+  }
+
+  override get testablePath(): string {
+    return this.testableState.availability.path;
+  }
+
   constructor(
     testableState: AvailabilityTestableState,
     suite: AvailabilityTestSuite,

package/src/stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.ts

@@ -49,7 +49,6 @@ import {
   type ExecutionResultWithMetadata,
   TDSExecutionResult,
   getColumn,
-  PrimitiveType,
   PRIMITIVE_TYPE,
   TDSRow,
   type Schema,
@@ -105,7 +104,7 @@ const buildTableToTDSQueryNonNumericWithColumnGrammar = (
   const db = table.schema._OWNER.path;
   const PREVIEW_COLUMN_NAME = 'Count Value';
   const columnGetter = getTDSColumnDerivedProperyFromType(
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+    getPrimitiveTypeFromRelationalType(column.type),
   );
   return `|${db}->tableReference(
     '${schemaName}',
@@ -135,7 +134,7 @@ const buildTableToTDSQueryNumericWithColumnGrammar = (
   const schemaName = table.schema.name;
   const db = table.schema._OWNER.path;
   const columnGetter = getTDSColumnDerivedProperyFromType(
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING,
+    getPrimitiveTypeFromRelationalType(column.type),
   );
   return `|${db}->tableReference(
     '${schemaName}',
@@ -181,9 +180,10 @@ const buildTableToTDSQueryNumericWithColumnGrammar = (
   )`;
 };
 
-const buildTableToTDSQueryColumnQuery = (column: Column): [string, boolean] => {
-  const type =
-    getPrimitiveTypeFromRelationalType(column.type) ?? PrimitiveType.STRING;
+export const buildTableToTDSQueryColumnQuery = (
+  column: Column,
+): [string, boolean] => {
+  const type = getPrimitiveTypeFromRelationalType(column.type);
   const numerics = [
     PRIMITIVE_TYPE.NUMBER,
     PRIMITIVE_TYPE.INTEGER,

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

@@ -30,6 +30,7 @@ import {
   AccessPoint,
   AccessPointGroup,
   CodeCompletionResult,
+  CompilationError,
   DataElement,
   DataElementReference,
   DataProduct,
@@ -136,7 +137,18 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
   readonly editorStore: EditorStore;
   readonly val: LakehouseAccessPointState;
   lambdaRelationColumns: string[] | undefined;
+  /**
+   * The engine's error message for this access point's lambda, when the engine
+   * answered that it could not compute the lambda's relation type.
+   */
+  lambdaRelationTypeError: string | undefined;
   isUpdatingRelationColumns = false;
+  /**
+   * Hash of the lambda the engine last answered for, with either its relation
+   * columns or an error for this lambda. A failure that is not an answer for
+   * this lambda (network, whole-batch failure) must leave it unset, so the next
+   * update asks the engine again.
+   */
   lastComputedLambdaHash: string | undefined;
   lastComputedLambdaString: string | undefined;
 
@@ -149,8 +161,10 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
 
     makeObservable(this, {
       lambdaRelationColumns: observable,
+      lambdaRelationTypeError: observable,
       isUpdatingRelationColumns: observable,
       setLambdaRelationColumns: action,
+      setLambdaRelationTypeError: action,
       updateLambdaRelationColumns: flow,
     });
   }
@@ -159,6 +173,10 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
     this.lambdaRelationColumns = columns;
   }
 
+  setLambdaRelationTypeError(message: string | undefined): void {
+    this.lambdaRelationTypeError = message;
+  }
+
   setIsUpdatingRelationColumns(value: boolean): void {
     this.isUpdatingRelationColumns = value;
   }
@@ -174,6 +192,7 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
     }
 
     this.setIsUpdatingRelationColumns(true);
+    this.setLambdaRelationTypeError(undefined);
     try {
       const relationType =
         (yield this.editorStore.graphManagerState.graphManager.getLambdaRelationType(
@@ -183,10 +202,22 @@ export class AccessPointLambdaEditorState extends LambdaEditorState {
       this.setLambdaRelationColumns(
         relationType.columns.map((column) => column.name),
       );
-    } catch {
+      this.lastComputedLambdaHash = lambdaHash;
+    } catch (error) {
+      assertErrorThrown(error);
       this.setLambdaRelationColumns(undefined);
+      if (error instanceof CompilationError) {
+        // the engine compiled this lambda and answered with an error for it
+        this.setLambdaRelationTypeError(error.message);
+        this.lastComputedLambdaHash = lambdaHash;
+      } else {
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+          `Can't get relation type for access point '${this.val.accessPoint.id}'`,
+          error,
+        );
+      }
     } finally {
-      this.lastComputedLambdaHash = lambdaHash;
       this.setIsUpdatingRelationColumns(false);
     }
   }
@@ -363,7 +394,10 @@ export class LakehouseAccessPointState extends AccessPointState {
     const lambdaColumns = this.lambdaState.lambdaRelationColumns;
 
     if (lambdaColumns === undefined) {
-      return `Fix compiler errors and make sure AccessPoint ${this.accessPoint.id} returns a Relation type`;
+      const engineError = this.lambdaState.lambdaRelationTypeError;
+      return `Fix compiler errors and make sure AccessPoint ${this.accessPoint.id} returns a Relation type${
+        engineError ? `. Engine error: ${engineError}` : ''
+      }`;
     }
 
     return `Sample values columns must match: [${lambdaColumns.join(', ')}]`;
@@ -931,9 +965,10 @@ export class DataProductEditorState extends ElementEditorState {
     if (entries.length === 0) {
       return;
     }
-    entries.forEach((entry) =>
-      entry.apState.lambdaState.setIsUpdatingRelationColumns(true),
-    );
+    entries.forEach((entry) => {
+      entry.apState.lambdaState.setIsUpdatingRelationColumns(true);
+      entry.apState.lambdaState.setLambdaRelationTypeError(undefined);
+    });
     try {
       const lambdas = new Map<string, RawLambda>(
         entries.map((entry) => [
@@ -941,28 +976,51 @@ export class DataProductEditorState extends ElementEditorState {
           entry.apState.accessPoint.func,
         ]),
       );
-      const { results } =
+      const { results, errors } =
         (yield this.editorStore.graphManagerState.graphManager.getBatchLambdasRelationType(
           lambdas,
           this.editorStore.graphManagerState.graph,
         )) as BatchLambdasRelationTypeResult;
       entries.forEach((entry) => {
+        const lambdaState = entry.apState.lambdaState;
         const relationType = results.get(entry.apState.uuid);
-        entry.apState.lambdaState.setLambdaRelationColumns(
-          relationType
-            ? relationType.columns.map((column) => column.name)
-            : undefined,
-        );
+        const engineError = errors.get(entry.apState.uuid);
+        if (relationType) {
+          lambdaState.setLambdaRelationColumns(
+            relationType.columns.map((column) => column.name),
+          );
+          lambdaState.lastComputedLambdaHash = entry.hash;
+        } else if (engineError) {
+          // the engine answered with an error for this lambda
+          lambdaState.setLambdaRelationColumns(undefined);
+          lambdaState.setLambdaRelationTypeError(engineError.message);
+          lambdaState.lastComputedLambdaHash = entry.hash;
+        } else {
+          // the engine did not answer for this lambda: leave the hash unset so
+          // the next update asks again
+          lambdaState.setLambdaRelationColumns(undefined);
+          this.editorStore.applicationStore.logService.error(
+            LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+            `Engine returned neither a relation type nor an error for access point '${entry.apState.accessPoint.id}'`,
+          );
+        }
       });
-    } catch {
+    } catch (error) {
+      assertErrorThrown(error);
+      // the whole batch failed, so no access point got an answer: leave their
+      // hashes unset so the next update asks again
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.GRAPH_MANAGER_FAILURE),
+        `Can't get relation types for access points`,
+        error,
+      );
       entries.forEach((entry) =>
         entry.apState.lambdaState.setLambdaRelationColumns(undefined),
       );
     } finally {
-      entries.forEach((entry) => {
-        entry.apState.lambdaState.lastComputedLambdaHash = entry.hash;
-        entry.apState.lambdaState.setIsUpdatingRelationColumns(false);
-      });
+      entries.forEach((entry) =>
+        entry.apState.lambdaState.setIsUpdatingRelationColumns(false),
+      );
     }
   }