@finos/legend-application-studio 28.18.147 → 28.19.0

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

@@ -68,9 +68,11 @@ import {
   QueryBuilderTelemetryHelper,
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
+  getRawLambdaForLetFuncs,
 } from '@finos/legend-query-builder';
 import { FunctionActivatorState } from './FunctionActivatorState.js';
 import { FunctionTestableState } from './function-activator/testable/FunctionTestableState.js';
+import { openDataCube } from '../../data-cube/LegendStudioDataCubeHelper.js';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
@@ -249,6 +251,24 @@ export class FunctionParametersState extends LambdaParametersState {
     );
   }
 
+  openDataCubeModal(
+    query: RawLambda,
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): void {
+    this.parameterStates = this.build(query);
+    this.parameterValuesEditorState.open(
+      (): Promise<void> =>
+        this.functionEditorState
+          .openingDataCube(element, editorStore)
+          .catch(
+            this.functionEditorState.editorStore.applicationStore
+              .alertUnhandledError,
+          ),
+      PARAMETER_SUBMIT_ACTION.RUN,
+    );
+  }
+
   build(lambda: RawLambda): LambdaParameterState[] {
     const parameters = buildLambdaVariableExpressions(
       lambda,
@@ -531,6 +551,36 @@ export class FunctionEditorState extends ElementEditorState {
     }
   }
 
+  async handleOpeningDataCube(
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const query = this.bodyExpressionSequence;
+    const parameters = (query.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.parametersState.openDataCubeModal(query, element, editorStore);
+    } else {
+      await openDataCube(element, editorStore);
+    }
+  }
+
+  async openingDataCube(
+    element: PackageableElement,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const params = buildExecutionParameterValues(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    const letFuncsRawLambda = getRawLambdaForLetFuncs(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    await openDataCube(element, editorStore, params, letFuncsRawLambda);
+  }
+
   *handleRunFunc(): GeneratorFn<void> {
     if (this.isRunningFunc) {
       return;

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

@@ -171,8 +171,9 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   };
 
   get storeValidationResult(): ValidationIssue | undefined {
-    return isStubbed_PackageableElement(this.connection.store.value)
-      ? createValidationError(['Connection database cannot be empty'])
+    return !this.connection.store ||
+      isStubbed_PackageableElement(this.connection.store.value)
+      ? createValidationError(['Connection database is empty'])
       : undefined;
   }
 

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

@@ -373,12 +373,15 @@ export class DatabaseSchemaExplorerState {
     });
 
     this.connection = connection;
-    this.database = guaranteeType(connection.store.value, Database);
+    this.database = guaranteeType(connection.store?.value, Database);
     this.editorStore = editorStore;
     this.targetDatabasePath = DEFAULT_DATABASE_PATH;
   }
 
   get isCreatingNewDatabase(): boolean {
+    if (!this.connection.store) {
+      return false;
+    }
     return isStubbed_PackageableElement(this.connection.store.value);
   }
 

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

@@ -44,20 +44,24 @@ import {
   ActionState,
   guaranteeNonNullable,
   assertTrue,
+  uuid,
 } from '@finos/legend-shared';
 import {
   dataProduct_addAccessPoint,
   dataProduct_addAccessPointGroup,
   dataProduct_deleteAccessPoint,
+  dataProduct_deleteAccessPointGroup,
 } from '../../../../graph-modifier/DSL_DataProduct_GraphModifierHelper.js';
 import { LambdaEditorState } from '@finos/legend-query-builder';
-import type { IngestionManager } from '../../../../ingestion/IngestionManager.js';
 import {
   DataProductElementEditorInitialConfiguration,
   EditorInitialConfiguration,
 } from '../ElementEditorInitialConfiguration.js';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig } from '../../../../../__lib__/LegendStudioNavigation.js';
-import type { AdhocDataProductDeployResponse } from '../../../../ingestion/AdhocDataProductDeployResponse.js';
+import type {
+  AdhocDataProductDeployResponse,
+  LakehouseIngestionManager,
+} from '@finos/legend-server-lakehouse';
 
 export class AccessPointState {
   readonly state: AccessPointGroupState;
@@ -187,6 +191,7 @@ export class LakehouseAccessPointState extends AccessPointState {
 
 export class AccessPointGroupState {
   readonly state: DataProductEditorState;
+  readonly uuid = uuid();
   value: AccessPointGroup;
   accessPointStates: AccessPointState[] = [];
 
@@ -248,11 +253,13 @@ export const generateUrlToDeployOnOpen = (
 
 export class DataProductEditorState extends ElementEditorState {
   accessPointModal = false;
+  accessPointGroupModal = false;
   deploymentState = ActionState.create();
   accessPointGroupStates: AccessPointGroupState[] = [];
   isConvertingTransformLambdaObjects = false;
   deployOnOpen = false;
   deployResponse: AdhocDataProductDeployResponse | undefined;
+  editingGroupState: AccessPointGroupState | undefined;
 
   constructor(
     editorStore: EditorStore,
@@ -264,6 +271,7 @@ export class DataProductEditorState extends ElementEditorState {
     makeObservable(this, {
       product: computed,
       accessPointModal: observable,
+      accessPointGroupModal: observable,
       accessPointGroupStates: observable,
       isConvertingTransformLambdaObjects: observable,
       deploy: flow,
@@ -272,8 +280,11 @@ export class DataProductEditorState extends ElementEditorState {
       setDeployOnOpen: action,
       setDeployResponse: action,
       setAccessPointModal: action,
+      setAccessPointGroupModal: action,
       addAccessPoint: action,
       convertAccessPointsFuncObjects: flow,
+      editingGroupState: observable,
+      setEditingGroupState: action,
     });
     this.accessPointGroupStates = this.product.accessPointGroups.map(
       (e) => new AccessPointGroupState(e, this),
@@ -336,6 +347,14 @@ export class DataProductEditorState extends ElementEditorState {
     this.accessPointModal = val;
   }
 
+  setEditingGroupState(val: AccessPointGroupState | undefined): void {
+    this.editingGroupState = val;
+  }
+
+  setAccessPointGroupModal(val: boolean): void {
+    this.accessPointGroupModal = val;
+  }
+
   addAccessPoint(
     id: string,
     description: string | undefined,
@@ -350,12 +369,12 @@ export class DataProductEditorState extends ElementEditorState {
     const groupState =
       accessPointGroup instanceof AccessPointGroupState
         ? accessPointGroup
-        : this.createBareGroupAndAdd(accessPointGroup);
+        : this.createGroupAndAdd(accessPointGroup);
     groupState.addAccessPoint(accesspoint);
     addUniqueEntry(this.accessPointGroupStates, groupState);
   }
 
-  createBareGroupAndAdd(id: string): AccessPointGroupState {
+  createGroupAndAdd(id: string, description?: string): AccessPointGroupState {
     const existingGroupState = this.accessPointGroupStates.find(
       (groupState) => groupState.value.id === id,
     );
@@ -365,10 +384,17 @@ export class DataProductEditorState extends ElementEditorState {
     }
     const group = new AccessPointGroup();
     group.id = id;
+    group.description = description;
     dataProduct_addAccessPointGroup(this.product, group);
     return new AccessPointGroupState(group, this);
   }
 
+  deleteAccessPointGroup(val: AccessPointGroupState): void {
+    const state = this.accessPointGroupStates.find((a) => a === val);
+    deleteEntry(this.accessPointGroupStates, state);
+    dataProduct_deleteAccessPointGroup(this.product, val.value);
+  }
+
   *deploy(token: string | undefined): GeneratorFn<void> {
     try {
       assertTrue(
@@ -426,7 +452,7 @@ export class DataProductEditorState extends ElementEditorState {
     return this.product.accessPointGroups.map((e) => e.accessPoints).flat();
   }
 
-  get ingestionManager(): IngestionManager | undefined {
+  get ingestionManager(): LakehouseIngestionManager | undefined {
     return this.editorStore.ingestionManager;
   }
 

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

@@ -201,19 +201,19 @@ export class HostedServiceFunctionActivatorEditorState extends ElementEditorStat
         .then((response) =>
           this.editorStore.applicationStore.alertService.setActionAlertInfo({
             message: `Hosted Service Function Activator has been deployed successfully`,
-            prompt: response.deploymentLocation
+            prompt: response.deployed
               ? 'You can now launch and monitor the operation of your function activator'
               : undefined,
             type: ActionAlertType.STANDARD,
             actions: [
-              ...(response.deploymentLocation !== undefined
+              ...(response.deployed !== undefined
                 ? [
                     {
                       label: 'Launch Service',
                       type: ActionAlertActionType.PROCEED,
                       handler: (): void => {
                         this.editorStore.applicationStore.navigationService.navigator.visitAddress(
-                          response.deploymentLocation ?? '',
+                          response.deployed ?? '',
                         );
                       },
                       default: true,

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

@@ -0,0 +1,130 @@
+/**
+ * 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 PackageableConnection,
+  MemSQLFunction,
+  ConnectionPointer,
+  InMemoryGraphData,
+  PackageableElementExplicitReference,
+  observe_MemSQLFunctionDeploymentConfiguration,
+  observe_MemSQLFunction,
+  DeploymentOwner,
+  observe_DeploymentOwnership,
+} from '@finos/legend-graph';
+import {
+  type GeneratorFn,
+  ActionState,
+  assertErrorThrown,
+  guaranteeType,
+} from '@finos/legend-shared';
+import { makeObservable, action, flow, computed } from 'mobx';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
+
+export class MemSQLFunctionActivatorEditorState extends ElementEditorState {
+  readonly validateState = ActionState.create();
+  readonly deployState = ActionState.create();
+
+  constructor(editorStore: EditorStore, element: MemSQLFunction) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      activator: computed,
+      reprocess: action,
+      updateOwnership: action,
+      updateAppDescription: action,
+      updateApplicationName: action,
+      updateConnection: action,
+      validate: flow,
+      deployToSandbox: flow,
+    });
+  }
+
+  get activator(): MemSQLFunction {
+    return observe_MemSQLFunction(
+      guaranteeType(
+        this.element,
+        MemSQLFunction,
+        'Element inside Mem SQL function editor state must be a MemSQLFunction',
+      ),
+    );
+  }
+
+  updateConnection(val: PackageableConnection): void {
+    this.activator.activationConfiguration.activationConnection =
+      new ConnectionPointer(PackageableElementExplicitReference.create(val));
+    observe_MemSQLFunctionDeploymentConfiguration(
+      this.activator.activationConfiguration,
+    );
+  }
+
+  updateOwnership(val: string): void {
+    this.activator.ownership = new DeploymentOwner(val, this.activator);
+    observe_DeploymentOwnership(this.activator.ownership);
+  }
+
+  updateApplicationName(val: string): void {
+    this.activator.functionName = val;
+  }
+
+  updateAppDescription(val: string): void {
+    this.activator.description = val;
+  }
+
+  *validate(): GeneratorFn<void> {
+    this.validateState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.validateFunctionActivator(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Function activator is valid`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.validateState.complete();
+    }
+  }
+
+  *deployToSandbox(): GeneratorFn<void> {
+    this.deployState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        'MemSQL Function Activator has been deployed successfully',
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.deployState.complete();
+    }
+  }
+
+  reprocess(
+    newElement: MemSQLFunction,
+    editorStore: EditorStore,
+  ): MemSQLFunctionActivatorEditorState {
+    return new MemSQLFunctionActivatorEditorState(editorStore, newElement);
+  }
+}

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

@@ -35,6 +35,10 @@ import {
 import { makeObservable, action, flow, computed } from 'mobx';
 import type { EditorStore } from '../../../EditorStore.js';
 import { ElementEditorState } from '../ElementEditorState.js';
+import {
+  ActionAlertActionType,
+  ActionAlertType,
+} from '@finos/legend-application';
 
 export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState {
   readonly validateState = ActionState.create();
@@ -122,13 +126,40 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
   *deployToSandbox(): GeneratorFn<void> {
     this.deployState.inProgress();
     try {
-      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
-        this.activator,
-        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
-      );
-      this.editorStore.applicationStore.notificationService.notifySuccess(
-        'SnowflakeApp Function Activator has been deployed successfully',
-      );
+      yield this.editorStore.graphManagerState.graphManager
+        .publishFunctionActivatorToSandbox(
+          this.activator,
+          new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+        )
+        .then((response) =>
+          this.editorStore.applicationStore.alertService.setActionAlertInfo({
+            message: `Snowflake UDTF has been deployed successfully`,
+            prompt: response.deploymentLocation
+              ? 'You can now call your UDTF on Snowflake'
+              : undefined,
+            type: ActionAlertType.STANDARD,
+            actions: [
+              ...(response.deploymentLocation !== undefined
+                ? [
+                    {
+                      label: 'Launch Snowflake UDTF',
+                      type: ActionAlertActionType.PROCEED,
+                      handler: (): void => {
+                        this.editorStore.applicationStore.navigationService.navigator.visitAddress(
+                          response.deploymentLocation ?? '',
+                        );
+                      },
+                      default: true,
+                    },
+                  ]
+                : []),
+              {
+                label: 'Close',
+                type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+              },
+            ],
+          }),
+        );
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.notificationService.notifyError(error);

package/src/stores/editor/editor-state/element-editor-state/ingest/IngestDefinitionEditorState.ts

@@ -27,7 +27,6 @@ import {
   removePrefix,
   type GeneratorFn,
 } from '@finos/legend-shared';
-import type { IngestionManager } from '../../../../ingestion/IngestionManager.js';
 import {
   action,
   computed,
@@ -39,8 +38,9 @@ import {
 import type {
   IngestDefinitionDeploymentResponse,
   IngestDefinitionValidationResponse,
+  LakehouseIngestionManager,
   ValidateAndDeploymentResponse,
-} from '../../../../ingestion/IngestionDeploymentResponse.js';
+} from '@finos/legend-server-lakehouse';
 import {
   EditorInitialConfiguration,
   IngestElementEditorInitialConfiguration,
@@ -113,7 +113,7 @@ export class IngestDefinitionEditorState extends ElementEditorState {
     );
   }
 
-  get ingestionManager(): IngestionManager | undefined {
+  get ingestionManager(): LakehouseIngestionManager | undefined {
     return this.editorStore.ingestionManager;
   }
 

package/src/stores/editor/editor-state/element-editor-state/service/ServiceExecutionState.ts

@@ -41,6 +41,7 @@ import {
   type QueryInfo,
   type LightQuery,
   type ExecutionResultWithMetadata,
+  type Service,
   PureSingleExecution,
   PureMultiExecution,
   KeyedExecutionParameter,
@@ -84,8 +85,10 @@ import {
   QUERY_BUILDER_EVENT,
   ExecutionPlanState,
   QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT,
+  getRawLambdaForLetFuncs,
 } from '@finos/legend-query-builder';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
+import { openDataCube } from '../../../data-cube/LegendStudioDataCubeHelper.js';
 
 export class ServiceExecutionParametersState extends LambdaParametersState {
   executionState: ServicePureExecutionState;
@@ -115,6 +118,24 @@ export class ServiceExecutionParametersState extends LambdaParametersState {
     );
   }
 
+  openDataCubeModal(
+    query: RawLambda,
+    element: Service,
+    editorStore: EditorStore,
+  ): void {
+    this.parameterStates = this.build(query);
+    this.parameterValuesEditorState.open(
+      (): Promise<void> =>
+        this.executionState
+          .openingDataCube(element, editorStore)
+          .catch(
+            this.executionState.editorStore.applicationStore
+              .alertUnhandledError,
+          ),
+      PARAMETER_SUBMIT_ACTION.RUN,
+    );
+  }
+
   build(query: RawLambda): LambdaParameterState[] {
     const parameters = buildLambdaVariableExpressions(
       query,
@@ -495,6 +516,36 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
     this.queryRunPromise = promise;
   };
 
+  async handleOpeningDataCube(
+    element: Service,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const query = this.queryState.query;
+    const parameters = (query.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.parametersState.openDataCubeModal(query, element, editorStore);
+    } else {
+      await openDataCube(element, editorStore);
+    }
+  }
+
+  async openingDataCube(
+    element: Service,
+    editorStore: EditorStore,
+  ): Promise<void> {
+    const params = buildExecutionParameterValues(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    const letFuncsRawLambda = getRawLambdaForLetFuncs(
+      this.parametersState.parameterStates,
+      this.editorStore.graphManagerState,
+    );
+
+    await openDataCube(element, editorStore, params, letFuncsRawLambda);
+  }
+
   *generatePlan(debug: boolean): GeneratorFn<void> {
     if (this.isGeneratingPlan) {
       return;

package/src/stores/editor/panel-group/SQLPlaygroundPanelState.ts

@@ -95,7 +95,7 @@ export class SQLPlaygroundPanelState implements CommandRegistrar {
     this.connection = val;
     if (val) {
       const connection = guaranteeRelationalDatabaseConnection(val);
-      this.database = connection.store.value;
+      this.database = connection.store?.value;
       this.schemaExplorerState = new DatabaseSchemaExplorerState(
         this.editorStore,
         connection,

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

@@ -71,6 +71,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   DATA = 'DATA',
   SNOWFLAKE_APP = 'SNOWFLAKE_APP',
   HOSTED_SERVICE = 'HOSTED_SERVICE',
+  MEM_SQL_FUNCTION = 'MEM_SQL_FUNCTION',
   // New Strategical Data Product
   _DATA_PRODUCT = 'BETA_DATA_PRODUCT',
 

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

@@ -32,14 +32,20 @@ export const dataProduct_deleteAccessPoint = action(
 );
 
 export const dataProduct_addAccessPoint = action(
-  (product: AccessPointGroup, accessPoint: AccessPoint) => {
-    addUniqueEntry(product.accessPoints, observe_AccessPoint(accessPoint));
+  (group: AccessPointGroup, accessPoint: AccessPoint) => {
+    addUniqueEntry(group.accessPoints, observe_AccessPoint(accessPoint));
   },
 );
 
 export const accessPointGroup_setDescription = action(
-  (product: AccessPointGroup, description: string) => {
-    product.description = description;
+  (group: AccessPointGroup, description: string) => {
+    group.description = description;
+  },
+);
+
+export const accessPointGroup_setName = action(
+  (group: AccessPointGroup, name: string) => {
+    group.id = name;
   },
 );
 

package/tsconfig.json

@@ -133,6 +133,7 @@
     "./src/stores/editor/editor-state/element-editor-state/external-format/DSL_ExternalFormat_SchemaSetEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/HostedServiceFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/INTERNAL__UnknownFunctionActivatorEditorState.ts",
+    "./src/stores/editor/editor-state/element-editor-state/function-activator/MemSQLFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/PostDeploymentActionEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.ts",
     "./src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts",
@@ -205,11 +206,6 @@
     "./src/stores/graph-modifier/STO_FlatData_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/STO_Relational_GraphModifierHelper.ts",
     "./src/stores/graph-modifier/Testable_GraphModifierHelper.ts",
-    "./src/stores/ingestion/AdhocDataProductDeployResponse.ts",
-    "./src/stores/ingestion/IngestDeploymentServerClient.ts",
-    "./src/stores/ingestion/IngestDiscoveryServerClient.ts",
-    "./src/stores/ingestion/IngestionDeploymentResponse.ts",
-    "./src/stores/ingestion/IngestionManager.ts",
     "./src/stores/lazy-text-editor/LazyTextEditorStore.ts",
     "./src/stores/project-reviewer/ProjectReviewerStore.ts",
     "./src/stores/project-view/ProjectViewerEditorMode.ts",
@@ -273,6 +269,7 @@
     "./src/components/editor/editor-group/function-activator/FunctionEditor.tsx",
     "./src/components/editor/editor-group/function-activator/HostedServiceFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/INTERNAL__UnknownFunctionActivatorEdtior.tsx",
+    "./src/components/editor/editor-group/function-activator/MemSQLFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.tsx",
     "./src/components/editor/editor-group/function-activator/testable/FunctionTestableEditor.tsx",
     "./src/components/editor/editor-group/ingest-editor/IngestDefinitionEditor.tsx",

package/lib/stores/ingestion/AdhocDataProductDeployResponse.d.ts

@@ -1,21 +0,0 @@
-/**
- * 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 { PlainObject } from '@finos/legend-shared';
-export declare class AdhocDataProductDeployResponse {
-    content: PlainObject;
-}
-export declare const createAdhocDataProductDeployResponse: (json: PlainObject<AdhocDataProductDeployResponse>) => AdhocDataProductDeployResponse;
-//# sourceMappingURL=AdhocDataProductDeployResponse.d.ts.map

package/lib/stores/ingestion/AdhocDataProductDeployResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdhocDataProductDeployResponse.d.ts","sourceRoot":"","sources":["../../../src/stores/ingestion/AdhocDataProductDeployResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,qBAAa,8BAA8B;IACzC,OAAO,EAAG,WAAW,CAAC;CACvB;AAED,eAAO,MAAM,oCAAoC,GAC/C,MAAM,WAAW,CAAC,8BAA8B,CAAC,KAChD,8BAIF,CAAC"}

package/lib/stores/ingestion/AdhocDataProductDeployResponse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdhocDataProductDeployResponse.js","sourceRoot":"","sources":["../../../src/stores/ingestion/AdhocDataProductDeployResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,OAAO,8BAA8B;IACzC,OAAO,CAAe;CACvB;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,IAAiD,EACjB,EAAE;IAClC,MAAM,QAAQ,GAAG,IAAI,8BAA8B,EAAE,CAAC;IACtD,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;IACxB,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC"}