@finos/legend-application-query 13.8.51 → 13.8.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-application-query",
-  "version": "13.8.51",
+  "version": "13.8.53",
   "description": "Legend Query application core",
   "keywords": [
     "legend",
@@ -44,18 +44,18 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@finos/legend-application": "16.0.122",
-    "@finos/legend-art": "7.1.162",
-    "@finos/legend-code-editor": "2.0.202",
-    "@finos/legend-data-cube": "0.3.120",
-    "@finos/legend-extension-dsl-data-space": "10.4.254",
-    "@finos/legend-graph": "32.6.33",
-    "@finos/legend-lego": "2.0.222",
-    "@finos/legend-query-builder": "4.19.11",
-    "@finos/legend-server-depot": "6.1.20",
-    "@finos/legend-server-lakehouse": "0.3.82",
-    "@finos/legend-shared": "11.0.28",
-    "@finos/legend-storage": "3.0.150",
+    "@finos/legend-application": "16.0.124",
+    "@finos/legend-art": "7.1.164",
+    "@finos/legend-code-editor": "2.0.204",
+    "@finos/legend-data-cube": "0.3.122",
+    "@finos/legend-extension-dsl-data-space": "10.4.256",
+    "@finos/legend-graph": "32.7.0",
+    "@finos/legend-lego": "2.0.224",
+    "@finos/legend-query-builder": "4.19.13",
+    "@finos/legend-server-depot": "6.1.21",
+    "@finos/legend-server-lakehouse": "0.3.84",
+    "@finos/legend-shared": "11.0.29",
+    "@finos/legend-storage": "3.0.151",
     "@testing-library/dom": "10.4.0",
     "@testing-library/react": "16.2.0",
     "@types/react": "19.0.10",

package/src/__lib__/LegendQueryEvent.ts

@@ -22,7 +22,14 @@ export enum LEGEND_QUERY_APP_EVENT {
   CREATE_QUERY__SUCCESS = 'query-editor.create-query.success',
   UPDATE_QUERY__SUCCESS = 'query-editor.update-query.success',
   RENAME_QUERY__SUCCESS = 'query-editor.rename.query.success',
+  DELETE_QUERY__SUCCESS = 'query-editor.delete-query.success',
+
+  CREATE_QUERY__FAILURE = 'query-editor.create-query.failure',
+  UPDATE_QUERY__FAILURE = 'query-editor.update-query.failure',
+  RENAME_QUERY__FAILURE = 'query-editor.rename-query.failure',
+  DELETE_QUERY__FAILURE = 'query-editor.delete-query.failure',
   INITIALIZE_QUERY_STATE__SUCCESS = 'query-editor.initialize-query-state.success',
+  INITIALIZE_QUERY_CREATOR__FAILURE = 'query-editor.initialize-query-creator.failure',
   LEGENDAI_QUERY_AGENT_CHAT__OPENED = 'query-editor.legendai-query-agent-chat.opened',
   LEGENDAI_QUERY_AGENT_CHAT__QUERY_LOADED = 'query-editor.legendai-query-agent-chat.query-loaded',
   LEGENDAI_QUERY_SUGGEST__LAUNCH = 'query-editor.legendai-query-suggest.launch',

package/src/__lib__/LegendQueryLifecycleTelemetry.ts

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { LightQuery } from '@finos/legend-graph';
+import { buildTelemetryErrorFields } from '@finos/legend-shared';
+import type { GenericLegendApplicationStore } from '@finos/legend-application';
+import type { CompleteQueryLoaderLifecycleHandlers } from '@finos/legend-query-builder';
+import {
+  type PartialQuery_TelemetryData,
+  type QueryCreateFailure_TelemetryData,
+  type QueryLifecycleFailure_TelemetryData,
+  type Query_TelemetryData,
+  LegendQueryTelemetryHelper,
+} from './LegendQueryTelemetryHelper.js';
+
+/**
+ * Builds the error half of a saved-query lifecycle failure payload, applying the
+ * same message cap and `errorMessageTruncated` flag as every other failure event.
+ */
+export const buildQueryLifecycleFailureData = (
+  queryId: string,
+  error: Error,
+): QueryLifecycleFailure_TelemetryData => ({
+  // NOTE: only the id is available on these paths — the loader reports a
+  // failure by id, and the query it refers to was never resolved
+  query: { id: queryId },
+  ...buildTelemetryErrorFields(error),
+});
+
+/**
+ * Maps a query to the identity block every lifecycle event carries.
+ */
+export const buildQueryIdentity = (query: LightQuery): Query_TelemetryData => ({
+  query: {
+    id: query.id,
+    name: query.name,
+    groupId: query.groupId,
+    artifactId: query.artifactId,
+    versionId: query.versionId,
+  },
+});
+
+/**
+ * Builds the payload for a failed *create*.
+ *
+ * Separate from {@link buildQueryLifecycleFailureData} because a failed create
+ * has no query to identify — the server assigns the id and the request never got
+ * that far. Reporting the chosen name instead of a placeholder id keeps "never
+ * persisted" distinguishable from a real value.
+ */
+export const buildQueryCreateFailureData = (
+  queryName: string,
+  error: Error,
+): QueryCreateFailure_TelemetryData => ({
+  queryName,
+  ...buildTelemetryErrorFields(error),
+});
+
+/**
+ * The saved-query lifecycle handlers every `QueryLoaderState` host wires in.
+ *
+ * Rename and delete happen inside the shared query loader, which reports them
+ * back through callbacks — so without this the same emit would be duplicated at
+ * each of the three hosts that build a loader (and before this existed, the
+ * rename emit was in fact triplicated while delete was reported nowhere).
+ *
+ * NOTE: these events deliberately carry no source info. They fire from the query
+ * *picker*, where the user may rename or delete one query while editing another
+ * — attaching the loaded query builder's source info would silently mislabel the
+ * row as belonging to the wrong query.
+ */
+export const buildQueryLoaderLifecycleTelemetryHandlers = (
+  applicationStore: GenericLegendApplicationStore,
+  sideEffects?:
+    | {
+        /**
+         * Runs alongside the delete telemetry — hosts use this to prune their
+         * recently-viewed list.
+         */
+        onQueryDeleted?: ((queryId: string) => void) | undefined;
+      }
+    | undefined,
+): CompleteQueryLoaderLifecycleHandlers => {
+  const { telemetryService } = applicationStore;
+  return {
+    onQueryRenamed: (query): void => {
+      LegendQueryTelemetryHelper.logEvent_RenameQuerySucceeded(
+        telemetryService,
+        buildQueryIdentity(query),
+      );
+    },
+    onQueryDeleted: (queryId, deletedQuery): void => {
+      sideEffects?.onQueryDeleted?.(queryId);
+      // the entry may not have been in the loaded list, in which case only the
+      // id is known
+      const identity: PartialQuery_TelemetryData = deletedQuery
+        ? buildQueryIdentity(deletedQuery)
+        : { query: { id: queryId } };
+      LegendQueryTelemetryHelper.logEvent_DeleteQuerySucceeded(
+        telemetryService,
+        identity,
+      );
+    },
+    onQueryRenameFailed: (queryId, error): void => {
+      // the rename failed, so the loader never resolved the renamed query —
+      // only its id and the error are known
+      LegendQueryTelemetryHelper.logEvent_RenameQueryFailed(
+        telemetryService,
+        buildQueryLifecycleFailureData(queryId, error),
+      );
+    },
+    onQueryDeleteFailed: (queryId, error): void => {
+      LegendQueryTelemetryHelper.logEvent_DeleteQueryFailed(
+        telemetryService,
+        buildQueryLifecycleFailureData(queryId, error),
+      );
+    },
+  };
+};

package/src/__lib__/LegendQueryNavigation.ts

@@ -442,6 +442,20 @@ export const EXTERNAL_APPLICATION_NAVIGATION__generateNewDataCubeUrl = (
   )}`;
 };
 
+/**
+ * Mirrors `generateAnchorForSection` from `@finos/legend-extension-dsl-data-product`,
+ * which this package does not depend on. The data product viewer registers one anchor
+ * per access point group, and reads the zone from the URL hash on load.
+ *
+ * @external_application_navigation This depends on Legend Marketplace routing and is hardcoded so it's potentially brittle
+ */
+const EXTERNAL_APPLICATION_NAVIGATION__generateAccessPointGroupAnchor = (
+  accessPointGroupId: string,
+): string =>
+  encodeURIComponent(
+    `apg-${accessPointGroupId}`.trim().toLowerCase().replace(/\s+/gu, '-'),
+  );
+
 /**
  * @external_application_navigation This depends on Legend Marketplace routing and is hardcoded so it's potentially brittle
  */
@@ -450,5 +464,10 @@ export const EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataProductUrl
     marketplaceApplicationUrl: string,
     dataProductId: string,
     deploymentId: string,
+    accessPointGroupId?: string | undefined,
   ): string =>
-    `${marketplaceApplicationUrl}/dataProduct/deployed/${dataProductId}/${deploymentId}`;
+    `${marketplaceApplicationUrl}/dataProduct/deployed/${dataProductId}/${deploymentId}${
+      accessPointGroupId
+        ? `#${EXTERNAL_APPLICATION_NAVIGATION__generateAccessPointGroupAnchor(accessPointGroupId)}`
+        : ''
+    }`;

package/src/__lib__/LegendQuerySourceInfo.ts

@@ -0,0 +1,162 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { LegendSourceInfo } from '@finos/legend-storage';
+
+/**
+ * The entry point a query creator was started from.
+ */
+export enum LegendQuerySourceType {
+  MAPPING = 'mapping',
+  SERVICE = 'service',
+  DATA_SPACE = 'data-space',
+  DATA_SPACE_TEMPLATE = 'data-space.template',
+  DATA_PRODUCT = 'data-product',
+  DATA_PRODUCT_SAMPLE = 'data-product.sample',
+  INGEST = 'ingest',
+  /**
+   * The default route, when no data product or data space has been selected yet
+   */
+  UNSELECTED = 'unselected',
+}
+
+/**
+ * Coordinates of the project the query is started from
+ */
+interface LegendQueryProjectSourceInfo extends LegendSourceInfo {
+  groupId: string;
+  artifactId: string;
+  versionId: string;
+  /**
+   * Set when a *saved* query was opened (the `/existing/:queryId` route) rather
+   * than a new one created from a creator route. The `sourceType` still
+   * describes what the query targets — a saved data space query reports
+   * `data-space`, same as a freshly created one — so a dashboard can slice by
+   * target without caring how the query was opened, and use the presence of
+   * this field to separate saved from new when it does care.
+   */
+  queryId?: string | undefined;
+}
+
+/**
+ * Query created on a mapping and runtime
+ * `/create/manual/:gav/:mappingPath/:runtimePath`
+ */
+export interface LegendQueryMappingSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.MAPPING;
+  mapping: string;
+  runtime: string;
+}
+
+/**
+ * Query created from a service
+ * `/create-from-service/:gav/:servicePath`
+ */
+export interface LegendQueryServiceSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.SERVICE;
+  service: string;
+}
+
+/**
+ * Query created on a data space
+ * `/dataspace/:gav/:dataSpacePath/:executionContext?`
+ */
+export interface LegendQueryDataSpaceSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.DATA_SPACE;
+  dataSpace: string;
+  /**
+   * The key of the execution context the query was started with, when known
+   */
+  executionContext?: string | undefined;
+}
+
+/**
+ * Query created from a data space template query
+ * `/dataspace/:gav/:dataSpacePath/template/:templateQueryId`
+ */
+export interface LegendQueryDataSpaceTemplateSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.DATA_SPACE_TEMPLATE;
+  dataSpace: string;
+  templateQueryId: string;
+}
+
+/**
+ * Query created on a data product
+ * `/data-product/:accessType/:gav/:dataProductPath/:accessId`
+ */
+export interface LegendQueryDataProductSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.DATA_PRODUCT;
+  dataProduct: string;
+  /**
+   * The access type (e.g. native, model, lakehouse) the query was started
+   * with, when known
+   */
+  accessType?: string | undefined;
+  /**
+   * The ID of the access point (group) or execution context the query was
+   * started with, when known
+   */
+  accessId?: string | undefined;
+}
+
+/**
+ * Query created from a data product sample query
+ * `/data-product/native/sample-query/:gav/:dataProductPath/:sampleQueryId`
+ */
+export interface LegendQueryDataProductSampleSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.DATA_PRODUCT_SAMPLE;
+  dataProduct: string;
+  sampleQueryId: string;
+}
+
+/**
+ * Query created on an ingest data set
+ * `/ingest/:gav/:ingestDefinitionPath/:dataSet`
+ */
+export interface LegendQueryIngestSourceInfo
+  extends LegendQueryProjectSourceInfo {
+  sourceType: LegendQuerySourceType.INGEST;
+  ingestDefinitionPath: string;
+  dataSet: string;
+}
+
+/**
+ * The default route `/`, when no data product or data space has been
+ * selected yet
+ */
+export interface LegendQueryUnselectedSourceInfo extends LegendSourceInfo {
+  sourceType: LegendQuerySourceType.UNSELECTED;
+}
+
+/**
+ * Where a query creator was started from, used as the query builder state
+ * source info (see `QueryBuilderState.sourceInfo`) and reported in telemetry
+ */
+export type LegendQuerySourceInfo =
+  | LegendQueryMappingSourceInfo
+  | LegendQueryServiceSourceInfo
+  | LegendQueryDataSpaceSourceInfo
+  | LegendQueryDataSpaceTemplateSourceInfo
+  | LegendQueryDataProductSourceInfo
+  | LegendQueryDataProductSampleSourceInfo
+  | LegendQueryIngestSourceInfo
+  | LegendQueryUnselectedSourceInfo;

package/src/__lib__/LegendQueryTelemetryHelper.ts

@@ -15,6 +15,7 @@
  */
 
 import type { TelemetryService } from '@finos/legend-application';
+import type { TelemetryErrorFields, TimingsRecord } from '@finos/legend-shared';
 import { LEGEND_QUERY_APP_EVENT } from './LegendQueryEvent.js';
 import {
   type GraphManagerOperationReport,
@@ -22,7 +23,7 @@ import {
   type GraphInitializationReport,
 } from '@finos/legend-graph';
 
-type Query_TelemetryData = {
+export type Query_TelemetryData = {
   query: {
     name: string;
     id: string;
@@ -46,6 +47,79 @@ type IntializeQueryState_TelemetryData = Query_TelemetryData &
     dependenciesCount: number;
   };
 
+/**
+ * Where the query creator was started from, returned by each creator store's
+ * `getInitializeTelemetrySource()`.
+ *
+ * The entry point the query creator was started from ({@link
+ * LegendQuerySourceInfo}) is spread FLAT into this payload, matching how
+ * `sourceInfo` is reported on every other query telemetry event.
+ *
+ * The index signature is what allows those flat keys — they vary by entry point
+ * and `LegendQuerySourceInfo` is a union, so they cannot be enumerated here.
+ * The union stays strictly typed where it is built, in each creator store's
+ * `getSourceInfo()` override.
+ */
+export type InitializeTelemetrySource = Record<PropertyKey, unknown> & {
+  /**
+   * Whether the most recently visited source was reopened, rather than the
+   * source being specified by the route
+   */
+  restoredFromRecent: boolean;
+};
+
+/**
+ * Base payload for the query creator failure event.
+ *
+ * There is no success counterpart: a successful load is reported by
+ * `query-builder.opened` from `legend-query-builder`, which fires for every
+ * route rather than creators only. This one survives because when a load fails
+ * there is no query builder to emit from, so it is the only record that an
+ * attempt happened.
+ */
+export type InitializeQueryCreator_TelemetryData = InitializeTelemetrySource & {
+  timings: TimingsRecord;
+};
+
+export type InitializeQueryCreatorFailure_TelemetryData =
+  InitializeQueryCreator_TelemetryData & TelemetryErrorFields;
+
+/**
+ * The query a lifecycle event acted on. `id` is always known for update, rename
+ * and delete — they act on a query that already exists. Identity beyond the id
+ * is partial: a delete resolves the entry from the loaded list, which may not
+ * contain it.
+ */
+export type PartialQuery_TelemetryData = {
+  query: {
+    id: string;
+    name?: string | undefined;
+    versionId?: string | undefined;
+    groupId?: string | undefined;
+    artifactId?: string | undefined;
+  };
+};
+
+/**
+ * Payload for a failed *create*.
+ *
+ * Deliberately has no `query` block: the server assigns the id, and a failed
+ * create never got that far, so no query exists to identify. The name the user
+ * chose is the only identity there is. Keeping this a separate type from
+ * {@link QueryLifecycleFailure_TelemetryData} means the three events that *do*
+ * always have an id cannot accidentally omit it.
+ */
+export type QueryCreateFailure_TelemetryData = {
+  queryName: string;
+} & TelemetryErrorFields;
+
+/**
+ * Payload for a failed update, rename or delete — actions on a query that
+ * already exists, so `query.id` is always present.
+ */
+export type QueryLifecycleFailure_TelemetryData = PartialQuery_TelemetryData &
+  TelemetryErrorFields;
+
 export class LegendQueryTelemetryHelper {
   static logEvent_ViewQuerySucceeded(
     service: TelemetryService,
@@ -64,6 +138,16 @@ export class LegendQueryTelemetryHelper {
     );
   }
 
+  static logEvent_InitializeQueryCreatorFailed(
+    service: TelemetryService,
+    data: InitializeQueryCreatorFailure_TelemetryData,
+  ): void {
+    service.logEvent(
+      LEGEND_QUERY_APP_EVENT.INITIALIZE_QUERY_CREATOR__FAILURE,
+      data,
+    );
+  }
+
   static logEvent_CreateQuerySucceeded(
     service: TelemetryService,
     data: Query_TelemetryData,
@@ -109,6 +193,41 @@ export class LegendQueryTelemetryHelper {
     service.logEvent(LEGEND_QUERY_APP_EVENT.RENAME_QUERY__SUCCESS, data);
   }
 
+  static logEvent_DeleteQuerySucceeded(
+    service: TelemetryService,
+    data: PartialQuery_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.DELETE_QUERY__SUCCESS, data);
+  }
+
+  static logEvent_CreateQueryFailed(
+    service: TelemetryService,
+    data: QueryCreateFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.CREATE_QUERY__FAILURE, data);
+  }
+
+  static logEvent_UpdateQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.UPDATE_QUERY__FAILURE, data);
+  }
+
+  static logEvent_RenameQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.RENAME_QUERY__FAILURE, data);
+  }
+
+  static logEvent_DeleteQueryFailed(
+    service: TelemetryService,
+    data: QueryLifecycleFailure_TelemetryData,
+  ): void {
+    service.logEvent(LEGEND_QUERY_APP_EVENT.DELETE_QUERY__FAILURE, data);
+  }
+
   static logEvent_QueryAISuggestLaunched(service: TelemetryService): void {
     service.logEvent(LEGEND_QUERY_APP_EVENT.LEGENDAI_QUERY_SUGGEST__LAUNCH, {});
   }

package/src/application/LegendQueryApplicationConfig.ts

@@ -142,7 +142,7 @@ export interface LegendQueryApplicationConfigurationData
   depot: {
     url: string;
   };
-  engine: { url: string; queryUrl?: string };
+  engine: { url: string; queryUrl?: string; useCookieAuthOnly?: boolean };
   studio: {
     url: string;
     instances: LegendStudioApplicationInstanceConfigurationData[];
@@ -171,6 +171,7 @@ export class LegendQueryApplicationConfig extends LegendApplicationConfig {
 
   readonly engineServerUrl: string;
   readonly engineQueryServerUrl?: string | undefined;
+  readonly engineUseCookieAuthOnly: boolean;
   readonly depotServerUrl: string;
   readonly studioApplicationUrl: string;
   readonly taxonomyApplicationUrl?: string;
@@ -204,6 +205,9 @@ export class LegendQueryApplicationConfig extends LegendApplicationConfig {
           input.configData.engine.queryUrl,
         )
       : undefined;
+    this.engineUseCookieAuthOnly = Boolean(
+      input.configData.engine.useCookieAuthOnly,
+    );
 
     // depot
     assertNonNullable(

package/src/components/Core_LegendQueryApplicationPlugin.tsx

@@ -141,6 +141,19 @@ import { LegendQueryDataProductQueryBuilderState } from '../stores/data-product/
 import { IngestLegendQueryBuilderState } from '../stores/ingest/IngestLegendQueryBuilderState.js';
 import { renderDataProductSampleQueryPanelContent } from './data-product/DataProductSampleQueryPanel.js';
 
+const isDataProductOrIngestQuery = (
+  queryBuilderState: QueryBuilderState,
+): boolean =>
+  queryBuilderState instanceof DataProductQueryBuilderState ||
+  queryBuilderState instanceof IngestLegendQueryBuilderState;
+
+const getUnsupportedExportActionMessage = (
+  queryBuilderState: QueryBuilderState,
+): string =>
+  isDataProductOrIngestQuery(queryBuilderState)
+    ? 'Not supported for Data Product or Ingest queries'
+    : 'Requires saved query';
+
 export const QUERY_DATACUBE_USAGE_TITLE = 'Legend DataCube';
 const QUERY_DATACUBE_SOURCE_TYPE = 'legendQuery';
 
@@ -387,6 +400,9 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
         title: 'Promote Curated Template query...',
         label: 'Curated Template Query',
         disableFunc: (queryBuilderState): boolean => {
+          if (isDataProductOrIngestQuery(queryBuilderState)) {
+            return true;
+          }
           if (
             queryBuilderState.workflowState.actionConfig instanceof
             QueryBuilderActionConfig_QueryApplication
@@ -463,13 +479,16 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           }
         },
         icon: <ArrowCircleUpIcon />,
-        disableMessage: 'Requires saved query',
+        getDisableMessage: getUnsupportedExportActionMessage,
       },
       {
         key: 'legend-datacube-query',
         title: 'Launch Legend DataCube...',
         label: 'Legend DataCube',
         disableFunc: (queryBuilderState): boolean => {
+          if (isDataProductOrIngestQuery(queryBuilderState)) {
+            return true;
+          }
           if (
             queryBuilderState.workflowState.actionConfig instanceof
             QueryBuilderActionConfig_QueryApplication
@@ -515,7 +534,7 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           }
         },
         icon: <CubeIcon />,
-        disableMessage: 'Requires saved query',
+        getDisableMessage: getUnsupportedExportActionMessage,
       },
     ];
   }

package/src/index.ts

@@ -21,7 +21,12 @@ export * from './application/LegendQueryPluginManager.js';
 
 export * from './__lib__/LegendQueryEvent.js';
 export * from './__lib__/LegendQueryEventHelper.js';
-export { LegendQueryTelemetryHelper } from './__lib__/LegendQueryTelemetryHelper.js';
+export {
+  LegendQueryTelemetryHelper,
+  type InitializeQueryCreator_TelemetryData,
+  type InitializeQueryCreatorFailure_TelemetryData,
+} from './__lib__/LegendQueryTelemetryHelper.js';
+export * from './__lib__/LegendQuerySourceInfo.js';
 export { LegendQueryAgentChatTelemetryHelper } from './__lib__/LegendQueryAgentChatTelemetryHelper.js';
 export {
   generateExistingQueryEditorRoute,

package/src/stores/EditExistingQuerySetupStore.ts

@@ -22,10 +22,10 @@ import { BaseQuerySetupStore } from './QuerySetupStore.js';
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import { quantifyList } from '@finos/legend-shared';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
+import { buildQueryLoaderLifecycleTelemetryHandlers } from '../__lib__/LegendQueryLifecycleTelemetry.js';
 import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
 import { QuerySearchSpecification, type LightQuery } from '@finos/legend-graph';
 import { generateExistingQueryEditorRoute } from '../__lib__/LegendQueryNavigation.js';
-import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
 
 export class EditExistingQuerySetupStore extends BaseQuerySetupStore {
   readonly queryLoaderState: QueryLoaderState;
@@ -74,25 +74,13 @@ export class EditExistingQuerySetupStore extends BaseQuerySetupStore {
                 'recently viewed queries',
               )}`
             : `No recently viewed queries`,
-        onQueryDeleted: (queryId): void =>
-          LegendQueryUserDataHelper.removeRecentlyViewedQuery(
-            this.applicationStore.userDataService,
-            queryId,
-          ),
-        onQueryRenamed: (query): void => {
-          LegendQueryTelemetryHelper.logEvent_RenameQuerySucceeded(
-            applicationStore.telemetryService,
-            {
-              query: {
-                id: query.id,
-                name: query.name,
-                groupId: query.groupId,
-                artifactId: query.artifactId,
-                versionId: query.versionId,
-              },
-            },
-          );
-        },
+        ...buildQueryLoaderLifecycleTelemetryHandlers(this.applicationStore, {
+          onQueryDeleted: (queryId): void =>
+            LegendQueryUserDataHelper.removeRecentlyViewedQuery(
+              this.applicationStore.userDataService,
+              queryId,
+            ),
+        }),
         handleFetchDefaultQueriesFailure: (): void =>
           LegendQueryUserDataHelper.removeRecentlyViewedQueries(
             this.applicationStore.userDataService,