@finos/legend-application-query 13.8.52 → 13.8.53

package/src/stores/LegendQueryApplicationPlugin.tsx

@@ -16,9 +16,16 @@
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
 import type {
+  DataProductAccessRequestLinkBuilder,
   QueryBuilder_LegendApplicationPlugin_Extension,
   QueryBuilderState,
 } from '@finos/legend-query-builder';
+import {
+  isSnapshotVersion,
+  SNAPSHOT_VERSION_ALIAS,
+} from '@finos/legend-server-depot';
+import { LegendQueryDataProductQueryBuilderState } from './data-product/query-builder/LegendQueryDataProductQueryBuilderState.js';
+import { EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataProductUrl } from '../__lib__/LegendQueryNavigation.js';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
 import type {
   ExistingQueryEditorStore,
@@ -136,4 +143,35 @@ export class LegendQueryApplicationPlugin
     request: QueryTitleDescriptionAISuggestionRequest,
     legendAIUrl: string,
   ) => Promise<QueryTitleDescriptionSuggestion>;
+
+  getDataProductAccessRequestLinkBuilders(): DataProductAccessRequestLinkBuilder[] {
+    return [
+      (info, queryBuilderState): string | undefined => {
+        if (
+          !(
+            queryBuilderState instanceof LegendQueryDataProductQueryBuilderState
+          ) ||
+          info.deploymentId === undefined
+        ) {
+          return undefined;
+        }
+        const versionId = queryBuilderState.project.versionId;
+        const marketplaceUrl =
+          isSnapshotVersion(versionId) || versionId === SNAPSHOT_VERSION_ALIAS
+            ? queryBuilderState.applicationStore.config
+                .marketplaceProductionParallelUrl
+            : queryBuilderState.applicationStore.config
+                .marketplaceApplicationUrl;
+        if (marketplaceUrl === undefined) {
+          return undefined;
+        }
+        return EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataProductUrl(
+          marketplaceUrl,
+          info.dataProductId,
+          info.deploymentId,
+          info.accessPointGroupId,
+        );
+      },
+    ];
+  }
 }

package/src/stores/QueryEditorStore.ts

@@ -39,6 +39,7 @@ import {
   returnUndefOnError,
   UnsupportedOperationError,
   filterByType,
+  buildTelemetryErrorFields,
 } from '@finos/legend-shared';
 import {
   type LightQuery,
@@ -138,9 +139,29 @@ import {
   ModelAccessPointDataProductExecutionState,
   LakehouseDataProductExecutionState,
   resolveDataProductAccessor,
+  QUERY_BUILDER_OPENED_FROM,
 } from '@finos/legend-query-builder';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
-import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
+import {
+  buildQueryCreateFailureData,
+  buildQueryIdentity,
+  buildQueryLifecycleFailureData,
+  buildQueryLoaderLifecycleTelemetryHandlers,
+} from '../__lib__/LegendQueryLifecycleTelemetry.js';
+import {
+  LegendQueryTelemetryHelper,
+  type InitializeTelemetrySource,
+} from '../__lib__/LegendQueryTelemetryHelper.js';
+import {
+  type LegendQueryDataProductSampleSourceInfo,
+  type LegendQueryDataProductSourceInfo,
+  type LegendQueryDataSpaceSourceInfo,
+  type LegendQueryIngestSourceInfo,
+  type LegendQueryMappingSourceInfo,
+  type LegendQueryServiceSourceInfo,
+  type LegendQuerySourceInfo,
+  LegendQuerySourceType,
+} from '../__lib__/LegendQuerySourceInfo.js';
 import { type ResolvedDataSpaceEntityWithOrigin } from '@finos/legend-extension-dsl-data-space/application';
 import {
   type DataSpace,
@@ -276,13 +297,7 @@ export class QueryCreatorState {
       LegendQueryTelemetryHelper.logEvent_CreateQuerySucceeded(
         this.editorStore.applicationStore.telemetryService,
         {
-          query: {
-            id: query.id,
-            name: query.name,
-            groupId: query.groupId,
-            artifactId: query.artifactId,
-            versionId: query.versionId,
-          },
+          ...buildQueryIdentity(query),
           ...queryBuilderState.getExtraTelemetryMetadata(),
         },
       );
@@ -300,6 +315,10 @@ export class QueryCreatorState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_CreateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryCreateFailureData(this.queryName, error),
+      );
     } finally {
       this.createQueryState.reset();
     }
@@ -430,25 +449,13 @@ export abstract class QueryEditorStore {
                 '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,
@@ -608,9 +615,9 @@ export abstract class QueryEditorStore {
       return;
     }
 
+    const stopWatch = new StopWatch();
     try {
       this.initState.inProgress();
-      const stopWatch = new StopWatch();
 
       // TODO: when we genericize the way to initialize an application page
       this.applicationStore.assistantService.setIsHidden(true);
@@ -624,6 +631,8 @@ export abstract class QueryEditorStore {
             baseUrl: this.applicationStore.config.engineServerUrl,
             queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
             enableCompression: true,
+            useCookieAuthOnly:
+              this.applicationStore.config.engineUseCookieAuthOnly,
           },
         },
         {
@@ -638,6 +647,15 @@ export abstract class QueryEditorStore {
       )) as QueryBuilderState;
       this.queryLoaderState.initialize(this.queryBuilderState);
       this.initState.pass();
+      // the canonical "a query builder is loaded" signal, emitted for every
+      // route — creator and saved alike. Reported here rather than from each
+      // route's own load event so that counting opens does not require a union
+      // of differently shaped, half-covering events.
+      this.queryBuilderState.logOpened(this.getOpenedFrom(), {
+        ...this.getInitializeTelemetrySource(),
+        timings:
+          this.applicationStore.timeService.finalizeTimingsRecord(stopWatch),
+      });
     } catch (error) {
       assertErrorThrown(error);
       this.applicationStore.logService.error(
@@ -645,6 +663,9 @@ export abstract class QueryEditorStore {
         error,
       );
       this.applicationStore.notificationService.notifyError(error);
+      // NOTE: log before handling the failure, which may reset the editor
+      // state that the telemetry source is derived from
+      this.logInitializeFailureMetrics(stopWatch, error);
       this.onInitializeFailure();
       this.initState.fail();
     }
@@ -654,6 +675,53 @@ export abstract class QueryEditorStore {
     // Do Nothing
   }
 
+  /**
+   * Where the query was started from, used as the source info of the query
+   * builder state. Since this is derived from the editor state (e.g. the
+   * route) rather than the query builder state, it is also available when
+   * the editor fails to initialize.
+   */
+  getSourceInfo(): LegendQuerySourceInfo | undefined {
+    return undefined;
+  }
+
+  /**
+   * Which surface opened the query builder, reported as `openedFrom` on
+   * `query-builder.opened`. Creator routes inherit this; only
+   * `ExistingQueryEditorStore` overrides it.
+   *
+   * Note this names the surface only — what is being queried is already carried
+   * by `getSourceInfo()` on the same payload.
+   */
+  getOpenedFrom(): QUERY_BUILDER_OPENED_FROM {
+    return QUERY_BUILDER_OPENED_FROM.QUERY_CREATOR;
+  }
+
+  /**
+   * Where the query was started from, reported when the query creator is
+   * initialized
+   */
+  getInitializeTelemetrySource(): InitializeTelemetrySource {
+    return {
+      // spread flat, matching how `sourceInfo` is reported on every other query
+      // telemetry event — see `QueryBuilderTelemetryContext`
+      ...this.getSourceInfo(),
+      restoredFromRecent: false,
+    };
+  }
+
+  logInitializeFailureMetrics(stopWatch: StopWatch, error: Error): void {
+    LegendQueryTelemetryHelper.logEvent_InitializeQueryCreatorFailed(
+      this.applicationStore.telemetryService,
+      {
+        ...this.getInitializeTelemetrySource(),
+        ...buildTelemetryErrorFields(error),
+        timings:
+          this.applicationStore.timeService.finalizeTimingsRecord(stopWatch),
+      },
+    );
+  }
+
   *searchExistingQueryName(searchText: string): GeneratorFn<void> {
     const isValidSearchString =
       searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
@@ -1282,6 +1350,10 @@ export abstract class QueryEditorStore {
       | ((val: ResolvedDataSpaceEntityWithOrigin) => void)
       | undefined,
     productSelectorState?: DataProductSelectorState | undefined,
+    sourceInfo?:
+      | LegendQueryDataProductSourceInfo
+      | LegendQueryDataProductSampleSourceInfo
+      | undefined,
   ): Promise<LegendQueryDataProductQueryBuilderState> {
     // 3. Build minimal graph and get analysis result
     const dataProductAnalysisResult =
@@ -1325,12 +1397,6 @@ export abstract class QueryEditorStore {
     }
     // 6. Create query builder state
     const projectInfo = { groupId, artifactId, versionId };
-    const sourceInfo = {
-      groupId,
-      artifactId,
-      versionId,
-      dataProduct: dataProductPath,
-    };
     const queryBuilderState = new LegendQueryDataProductQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
@@ -1348,11 +1414,20 @@ export abstract class QueryEditorStore {
         new DataProductSelectorState(
           this.depotServerClient,
           this.applicationStore,
+          this.lakehouseState?.contractServerClient,
         ),
       onLegacyDataSpaceChange,
       undefined,
       this.applicationStore.config.options.queryBuilderConfig,
-      sourceInfo,
+      sourceInfo ?? {
+        sourceType: LegendQuerySourceType.DATA_PRODUCT,
+        groupId,
+        artifactId,
+        versionId,
+        dataProduct: dataProductPath,
+        accessType: dataProductAccessType,
+        accessId,
+      },
     );
 
     if (
@@ -1449,13 +1524,19 @@ export class MappingQueryCreatorStore extends QueryEditorStore {
     };
   }
 
-  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
-    const projectInfo = this.getProjectInfo();
-    const sourceInfo = {
-      groupId: projectInfo.groupId,
-      artifactId: projectInfo.artifactId,
-      versionId: projectInfo.versionId,
+  override getSourceInfo(): LegendQueryMappingSourceInfo {
+    return {
+      sourceType: LegendQuerySourceType.MAPPING,
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+      mapping: this.mappingPath,
+      runtime: this.runtimePath,
     };
+  }
+
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
+    const sourceInfo = this.getSourceInfo();
     const queryBuilderState = new MappingQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
@@ -1574,6 +1655,16 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
     };
   }
 
+  override getSourceInfo(): LegendQueryServiceSourceInfo {
+    return {
+      sourceType: LegendQuerySourceType.SERVICE,
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+      service: this.servicePath,
+    };
+  }
+
   async initializeQueryBuilderState(): Promise<QueryBuilderState> {
     const service = this.graphManagerState.graph.getService(this.servicePath);
     assertType(
@@ -1582,13 +1673,7 @@ export class ServiceQueryCreatorStore extends QueryEditorStore {
       `Can't process service execution: only Pure execution is supported`,
     );
 
-    const projectInfo = this.getProjectInfo();
-    const sourceInfo = {
-      groupId: projectInfo.groupId,
-      artifactId: projectInfo.artifactId,
-      versionId: projectInfo.versionId,
-      service: service.path,
-    };
+    const sourceInfo = this.getSourceInfo();
     const queryBuilderState = new ServiceQueryBuilderState(
       this.applicationStore,
       this.graphManagerState,
@@ -1799,13 +1884,7 @@ export class ExistingQueryUpdateState {
       LegendQueryTelemetryHelper.logEvent_UpdateQuerySucceeded(
         this.editorStore.applicationStore.telemetryService,
         {
-          query: {
-            id: query.id,
-            name: query.name,
-            groupId: query.groupId,
-            artifactId: query.artifactId,
-            versionId: query.versionId,
-          },
+          ...buildQueryIdentity(query),
           ...queryBuilderState.getExtraTelemetryMetadata(),
         },
       );
@@ -1819,6 +1898,10 @@ export class ExistingQueryUpdateState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryLifecycleFailureData(this.editorStore.id, error),
+      );
     } finally {
       this.updateQueryState.complete();
     }
@@ -1848,13 +1931,7 @@ export class ExistingQueryUpdateState {
       LegendQueryTelemetryHelper.logEvent_UpdateQuerySucceeded(
         this.editorStore.applicationStore.telemetryService,
         {
-          query: {
-            id: updatedQuery.id,
-            name: updatedQuery.name,
-            groupId: updatedQuery.groupId,
-            artifactId: updatedQuery.artifactId,
-            versionId: updatedQuery.versionId,
-          },
+          ...buildQueryIdentity(updatedQuery),
           ...extraTelemetryMetadata,
         },
       );
@@ -1865,6 +1942,10 @@ export class ExistingQueryUpdateState {
         error,
       );
       this.editorStore.applicationStore.notificationService.notifyError(error);
+      LegendQueryTelemetryHelper.logEvent_UpdateQueryFailed(
+        this.editorStore.applicationStore.telemetryService,
+        buildQueryLifecycleFailureData(queryId, error),
+      );
     } finally {
       this.updateQueryState.complete();
     }
@@ -2002,17 +2083,19 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       this.applicationStore.telemetryService,
       {
         graph: graphBuilderReportData,
-        query: {
-          id: currentQuery.id,
-          name: currentQuery.name,
-          groupId: currentQuery.groupId,
-          artifactId: currentQuery.artifactId,
-          versionId: currentQuery.versionId,
-        },
+        ...buildQueryIdentity(currentQuery),
       },
     );
   }
 
+  override getOpenedFrom(): QUERY_BUILDER_OPENED_FROM {
+    return QUERY_BUILDER_OPENED_FROM.QUERY_SAVED;
+  }
+
+  override logInitializeFailureMetrics(): void {
+    // Do nothing: an existing query is not a query creator
+  }
+
   setLightQuery(val: LightQuery): void {
     this._lightQuery = val;
   }
@@ -2162,12 +2245,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         runtime,
       );
       if (matchingExecutionContext) {
-        const sourceInfo = {
+        const sourceInfo: LegendQueryDataSpaceSourceInfo = {
+          sourceType: LegendQuerySourceType.DATA_SPACE,
           groupId: queryInfo.groupId,
           artifactId: queryInfo.artifactId,
           versionId: queryInfo.versionId,
           queryId: queryInfo.id,
           dataSpace: dataSpace.path,
+          executionContext: exec.executionKey,
         };
         const visitedDataSpaces =
           LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(
@@ -2264,6 +2349,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             new DataProductSelectorState(
               this.depotServerClient,
               this.applicationStore,
+              this.lakehouseState?.contractServerClient,
             ),
             () => {
               this.applicationStore.notificationService.notifyWarning(
@@ -2318,11 +2404,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       }
     } else if (exec instanceof QueryExplicitExecutionContextInfo) {
       const projectInfo = this.getProjectInfo();
-      const sourceInfo = {
+      const sourceInfo: LegendQueryMappingSourceInfo = {
+        sourceType: LegendQuerySourceType.MAPPING,
         groupId: projectInfo.groupId,
         artifactId: projectInfo.artifactId,
         versionId: projectInfo.versionId,
         queryId: queryInfo.id,
+        mapping: exec.mapping,
+        runtime: exec.runtime,
       };
       const classQueryBuilderState = new ClassQueryBuilderState(
         this.applicationStore,
@@ -2387,6 +2476,18 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             'Switching data products is not supported from the existing query editor. Please open a new query instead.',
           );
         },
+        undefined,
+        undefined,
+        {
+          sourceType: LegendQuerySourceType.DATA_PRODUCT,
+          groupId: queryInfo.groupId,
+          artifactId: queryInfo.artifactId,
+          versionId: queryInfo.versionId,
+          queryId: queryInfo.id,
+          dataProduct: exec.dataProductPath,
+          accessType,
+          accessId: executionContextId,
+        },
       );
       return queryBuilderState;
     } else if (exec instanceof QueryIngestExecutionContextInfo) {
@@ -2445,11 +2546,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         projectInfo,
         this.applicationStore.config.options.queryBuilderConfig,
         {
+          sourceType: LegendQuerySourceType.INGEST,
           groupId: projectInfo.groupId,
           artifactId: projectInfo.artifactId,
           versionId: projectInfo.versionId,
           queryId: queryInfo.id,
-        },
+          ingestDefinitionPath: exec.ingestDefinitionPath,
+          dataSet: exec.dataSet,
+        } satisfies LegendQueryIngestSourceInfo,
       );
       await ingestQueryBuilderState.changeAccessorOwner(ingestDefinition);
       await ingestQueryBuilderState.changeAccessor({
@@ -2537,26 +2641,14 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
       this.applicationStore.telemetryService,
       {
         ...initailizeQueryStateReport,
-        query: {
-          id: query.id,
-          name: query.name,
-          groupId: query.groupId,
-          artifactId: query.artifactId,
-          versionId: query.versionId,
-        },
+        ...buildQueryIdentity(query),
       },
     );
     LegendQueryTelemetryHelper.logEvent_ViewQuerySucceeded(
       this.applicationStore.telemetryService,
       {
         ...report,
-        query: {
-          id: query.id,
-          name: query.name,
-          groupId: query.groupId,
-          artifactId: query.artifactId,
-          versionId: query.versionId,
-        },
+        ...buildQueryIdentity(query),
       },
     );
     return queryBuilderState;

package/src/stores/QueryProductionizerSetupStore.ts

@@ -25,8 +25,8 @@ import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioProductionizeQueryUrl } from '../__lib__/LegendQueryNavigation.js';
 import { BaseQuerySetupStore } from './QuerySetupStore.js';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
+import { buildQueryLoaderLifecycleTelemetryHandlers } from '../__lib__/LegendQueryLifecycleTelemetry.js';
 import { quantifyList } from '@finos/legend-shared';
-import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
 
 export class QueryProductionizerSetupStore extends BaseQuerySetupStore {
   readonly queryLoaderState: QueryLoaderState;
@@ -61,25 +61,13 @@ export class QueryProductionizerSetupStore 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,

package/src/stores/QuerySetupStore.ts

@@ -81,6 +81,8 @@ export abstract class BaseQuerySetupStore {
             baseUrl: this.applicationStore.config.engineServerUrl,
             queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
             enableCompression: true,
+            useCookieAuthOnly:
+              this.applicationStore.config.engineUseCookieAuthOnly,
           },
         },
         {

package/src/stores/data-product/DataProductSampleQueryCreatorStore.ts

@@ -23,6 +23,10 @@ import { generateDataProductSampleQueryRoute } from '../../__lib__/LegendQueryNa
 import { DataProductSelectorState } from '../data-space/DataProductSelectorState.js';
 import { createQueryDataProductTaggedValue } from '../../components/data-product/QueryDataProductUtil.js';
 import { BaseTemplateQueryCreatorStore } from '../BaseTemplateQueryCreatorStore.js';
+import {
+  type LegendQueryDataProductSampleSourceInfo,
+  LegendQuerySourceType,
+} from '../../__lib__/LegendQuerySourceInfo.js';
 
 export class DataProductSampleQueryCreatorStore extends BaseTemplateQueryCreatorStore {
   readonly dataProductPath: string;
@@ -77,6 +81,17 @@ export class DataProductSampleQueryCreatorStore extends BaseTemplateQueryCreator
     return [createQueryDataProductTaggedValue(this.dataProductPath)];
   }
 
+  override getSourceInfo(): LegendQueryDataProductSampleSourceInfo {
+    return {
+      sourceType: LegendQuerySourceType.DATA_PRODUCT_SAMPLE,
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+      dataProduct: this.dataProductPath,
+      sampleQueryId: this.templateQueryId,
+    };
+  }
+
   async initializeQueryBuilderState(): Promise<QueryBuilderState> {
     const artifact = await this.fetchDataProductArtifact(
       this.groupId,
@@ -120,7 +135,9 @@ export class DataProductSampleQueryCreatorStore extends BaseTemplateQueryCreator
       new DataProductSelectorState(
         this.depotServerClient,
         this.applicationStore,
+        this.lakehouseState?.contractServerClient,
       ),
+      this.getSourceInfo(),
     );
 
     const query = await this.graphManagerState.graphManager.pureCodeToLambda(